repo: update from holylib

Author: RaphaelIT7

README.md

@@ -64,21 +64,25 @@ Returns true if the HTTPServer is running.
 #### HttpServer:SetTCPnodelay(bool nodelay)
 Sets whether a delay should be added to tcp or not.
 
-#### HttpServer:SetReadTimeout(int sec, int usec)
+#### HttpServer:SetReadTimeout(number sec, number usec)
 Sets the maximum amount of time before a read times out.
 
-#### HttpServer:SetWriteTimeout(int sec, int usec)
+#### HttpServer:SetWriteTimeout(number sec, number usec)
 Sets the maximum amount of time before a write times out.
 
-#### HttpServer:SetPayloadMaxLength(int maxlength)
+#### HttpServer:SetPayloadMaxLength(number maxlength)
 Sets the maximum payload length.
 
-#### HttpServer:SetKeepAliveTimeout(int sec)
+#### HttpServer:SetKeepAliveTimeout(number sec)
 Sets the maximum time a connection is kept alive.
 
-#### HttpServer:SetKeepAliveMaxCount(int amount)
+#### HttpServer:SetKeepAliveMaxCount(number amount)
 Sets the maximum amount of connections that can be kept alive at the same time.
 
+#### HttpServer:SetThreadSleep(number sleepTime)
+The number of ms threads sleep before checking again if a request was handled.  
+Useful to raise it when you let requests wait for a while.
+
 #### HttpServer:SetMountPoint(string path, string folder)
 This mounts the given folder to the given path.
 (You can call this multiple times for the same path to mount multiple folders to it.)

source/httpserver.cpp

@@ -11,7 +11,11 @@ void CallFunc(int func, HttpRequest* request, HttpResponse* response)
 	Push_HttpRequest(request);
 	Push_HttpResponse(response);
 
-	g_Lua->PCall(2, 0, 0);
+	if (g_Lua->CallFunctionProtected(2, 1, true))
+	{
+		request->bHandled = !g_Lua->GetBool(-1);
+		g_Lua->Pop(1);
+	}
 
 	Delete_HttpRequest(request);
 	Delete_HttpResponse(response); // Destroys the Lua reference after we used it
@@ -43,27 +47,32 @@ void HttpServer::Think()
 		return;
 
 	m_bInUpdate = true;
-	for (auto it = m_pRequests.begin(); it != m_pRequests.end(); ++it) {
+	for (auto it = m_pRequests.begin(); it != m_pRequests.end(); ++it)
+	{
 		auto pEntry = (*it);
-		if (pEntry->bHandled) { continue; }
-		if (pEntry->bDelete) {
+		if (pEntry->bDelete)
+		{
 			it = m_pRequests.erase(it);
 			delete pEntry;
 			continue;
 		}
 
-		CallFunc(pEntry->iFunction, pEntry, &pEntry->pResponseData);
-		pEntry->bHandled = true;
+		if (!pEntry->bHandled)
+			CallFunc(pEntry->iFunction, pEntry, &pEntry->pResponseData);
 	}
 
 	m_bUpdate = false;
 	m_bInUpdate = false;
 }
 
-httplib::Server::Handler HttpServer::CreateHandler(const char* path, int func, bool ipwhitelist)
+static std::string localAddr = "127.0.0.1";
+static std::string loopBack = "loopback";
+httplib::Server::Handler HttpServer::CreateHandler(const char* path, int func, bool ipWhitelist)
 {
-	return [=](const httplib::Request& req, httplib::Response& res) {
-		if (ipwhitelist) {
+	return [=](const httplib::Request& req, httplib::Response& res)
+	{
+		if (ipWhitelist)
+		{
 			bool found = false;
 			for (auto& pClient : Util::GetClients())
 			{
@@ -73,13 +82,15 @@ httplib::Server::Handler HttpServer::CreateHandler(const char* path, int func, b
 				const netadr_s& addr = pClient->GetNetChannel()->GetRemoteAddress();
 				std::string address = addr.ToString();
 				size_t port_pos = address.find(":");
-				if (address.substr(0, port_pos) == req.remote_addr || (req.remote_addr == "127.0.0.1" && address.substr(0, port_pos) == "loopback")) {
+				if (address.substr(0, port_pos) == req.remote_addr || (req.remote_addr == localAddr && address.substr(0, port_pos) == loopBack))
+				{
 					found = true;
 					break;
 				}
 			}
 
-			if (!found) { return; }
+			if (!found)
+				return;
 		}
 
 		HttpRequest* request = new HttpRequest;
@@ -89,23 +100,19 @@ httplib::Server::Handler HttpServer::CreateHandler(const char* path, int func, b
 		request->pResponse = res;
 		m_pRequests.push_back(request); // We should add a check here since we could write to it from multiple threads?
 		m_bUpdate = true;
-		while (!request->bHandled) {
-			ThreadSleep(1);
-		}
+		while (!request->bHandled)
+			ThreadSleep(m_iThreadSleep);
+
 		HttpResponse* rdata = &request->pResponseData;
-		if (rdata->bSetContent) {
+		if (rdata->bSetContent)
 			res.set_content(rdata->strContent, rdata->strContentType);
-		}
 
-		if (rdata->bSetRedirect) {
+		if (rdata->bSetRedirect)
 			res.set_redirect(rdata->strRedirect, rdata->iRedirectCode);
-		}
 
-		if (rdata->bSetHeader) {
-			for (auto& [key, value] : rdata->pHeaders) {
+		if (rdata->bSetHeader)
+			for (auto& [key, value] : rdata->pHeaders)
 				res.set_header(key, value);
-			}
-		}
 
 		request->bDelete = true;
 	};

source/httpserver.h

@@ -1,6 +1,5 @@
-#include "GarrysMod/Lua/Interface.h"
-#include "unordered_map"
 #include "httplib.h"
+#include "unordered_map"
 
 struct HttpResponse {
 	bool bSetContent = false;
@@ -14,8 +13,10 @@ struct HttpResponse {
 };
 
 struct HttpRequest {
+	~HttpRequest();
+
 	bool bHandled = false;
-	bool bDelete = false;
+	bool bDelete = false; // We only delete from the main thread.
 	int iFunction;
 	std::string strPath;
 	HttpResponse pResponseData;
@@ -48,47 +49,49 @@ class HttpServer
 		return 0;
 	}
 
-	void Get(const char* path, int func, bool ipwhitelist)
+	void Get(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Get(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Get(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	void Post(const char* path, int func, bool ipwhitelist)
+	void Post(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Post(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Post(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	void Put(const char* path, int func, bool ipwhitelist)
+	void Put(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Put(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Put(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	void Patch(const char* path, int func, bool ipwhitelist)
+	void Patch(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Patch(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Patch(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	void Delete(const char* path, int func, bool ipwhitelist)
+	void Delete(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Delete(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Delete(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	void Options(const char* path, int func, bool ipwhitelist)
+	void Options(const char* path, int func, bool ipWhitelist)
 	{
-		m_pServer.Options(path, CreateHandler(path, func, ipwhitelist));
+		m_pServer.Options(path, CreateHandler(path, func, ipWhitelist));
 	}
 
-	httplib::Server::Handler CreateHandler(const char*, int, bool);
+	httplib::Server::Handler CreateHandler(const char* path, int func, bool ipWhitelist);
 
 public:
 	httplib::Server& GetServer() { return m_pServer; };
 	unsigned char GetStatus() { return m_iStatus; };
 	std::string& GetAddress() { return m_strAddress; };
 	unsigned short GetPort() { return m_iPort; };
+	void SetThreadSleep(unsigned int threadSleep) { m_iThreadSleep = threadSleep; };
 
 private:
 	unsigned char m_iStatus = HTTPSERVER_OFFLINE;
 	unsigned short m_iPort;
+	unsigned int m_iThreadSleep = 5; // How long the threads sleep / wait for a request to be handled
 	bool m_bUpdate = false;
 	bool m_bInUpdate = false;
 	std::string m_strAddress;

source/lua.cpp

@@ -165,20 +165,23 @@ LUA_FUNCTION_STATIC(HttpServer_SetReadTimeout)
 {
 	HttpServer* pServer = Get_HttpServer(1, true);
 	pServer->GetServer().set_read_timeout((time_t)LUA->CheckNumber(2), (time_t)LUA->CheckNumber(3));
+
 	return 0;
 }
 
 LUA_FUNCTION_STATIC(HttpServer_SetWriteTimeout)
 {
 	HttpServer* pServer = Get_HttpServer(1, true);
 	pServer->GetServer().set_write_timeout((time_t)LUA->CheckNumber(1), (time_t)LUA->CheckNumber(2));
+
 	return 0;
 }
 
 LUA_FUNCTION_STATIC(HttpServer_SetPayloadMaxLength)
 {
 	HttpServer* pServer = Get_HttpServer(1, true);
 	pServer->GetServer().set_payload_max_length((size_t)LUA->CheckNumber(2));
+
 	return 0;
 }
 
@@ -233,18 +236,18 @@ LUA_FUNCTION_STATIC(HttpServer_Stop)
 	return 0;
 }
 
-LUA_FUNCTION_STATIC(httpserver_Create)
+LUA_FUNCTION_STATIC(HttpServer_SetThreadSleep)
 {
-	Push_HttpServer(new HttpServer);
-	return 1;
+	HttpServer* pServer = Get_HttpServer(1, true);
+	pServer->SetThreadSleep((unsigned int)LUA->CheckNumber(2));
+
+	return 0;
 }
 
-LUA_FUNCTION_STATIC(httpserver_Think)
+LUA_FUNCTION_STATIC(httpserver_Create)
 {
-	for (auto& [httpserver, _] : g_pPushedHttpServer)
-		httpserver->Think();
-
-	return 0;
+	Push_HttpServer(new HttpServer);
+	return 1;
 }
 
 LUA_FUNCTION_STATIC(httpserver_Destroy)
@@ -260,6 +263,14 @@ LUA_FUNCTION_STATIC(httpserver_Destroy)
 	return 0;
 }
 
+LUA_FUNCTION_STATIC(httpserver_Think)
+{
+	for (auto& [httpserver, _] : g_pPushedHttpServer)
+		httpserver->Think();
+
+	return 0;
+}
+
 void LUA_InitServer(GarrysMod::Lua::ILuaBase* LUA)
 {
 	HttpRequest_LuaInit();
@@ -281,6 +292,7 @@ void LUA_InitServer(GarrysMod::Lua::ILuaBase* LUA)
 		Util::AddFunc(HttpServer_SetPayloadMaxLength, "SetPayloadMaxLength");
 		Util::AddFunc(HttpServer_SetKeepAliveTimeout, "SetKeepAliveTimeout");
 		Util::AddFunc(HttpServer_SetKeepAliveMaxCount, "SetKeepAliveMaxCount");
+		Util::AddFunc(HttpServer_SetThreadSleep, "SetThreadSleep");
 
 		Util::AddFunc(HttpServer_SetMountPoint, "SetMountPoint");
 		Util::AddFunc(HttpServer_RemoveMountPoint, "RemoveMountPoint");

source/requestdata.cpp

@@ -4,6 +4,16 @@ static int HttpResponse_TypeID = -1;
 PushReferenced_LuaClass(HttpResponse, HttpResponse_TypeID)
 Get_LuaClass(HttpResponse, HttpResponse_TypeID, "HttpResponse")
 
+static int HttpRequest_TypeID = -1;
+PushReferenced_LuaClass(HttpRequest, HttpRequest_TypeID)
+Get_LuaClass(HttpRequest, HttpRequest_TypeID, "HttpRequest")
+
+HttpRequest::~HttpRequest()
+{
+	Delete_HttpRequest(this);
+	Delete_HttpResponse(&this->pResponseData);
+}
+
 LUA_FUNCTION_STATIC(HttpResponse__tostring)
 {
 	HttpResponse* pData = Get_HttpResponse(1, false);
@@ -75,10 +85,6 @@ LUA_FUNCTION_STATIC(HttpResponse_SetHeader)
 	return 0;
 }
 
-static int HttpRequest_TypeID = -1;
-PushReferenced_LuaClass(HttpRequest, HttpRequest_TypeID)
-Get_LuaClass(HttpRequest, HttpRequest_TypeID, "HttpRequest")
-
 LUA_FUNCTION_STATIC(HttpRequest__tostring)
 {
 	HttpRequest* pData = Get_HttpRequest(1, false);

source/util.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "LuaInterface.h"
 #include "httpserver.h"
+#include "LuaInterface.h"
 #include <string>
 #include "lua.h"
 #include <vector>