v0.7.7

Author: taronsarkisyan

README.md

@@ -1,6 +1,6 @@
 <img src="https://static.wikia.nocookie.net/arnelify/images/c/c8/Arnelify-logo-2024.png/revision/latest?cb=20240701012515" style="width:336px;" alt="Arnelify Logo" />
 
-![Arnelify Server for Python](https://img.shields.io/badge/Arnelify%20Server%20for%20Python-0.7.5-yellow) ![C++](https://img.shields.io/badge/C++-2b-red) ![G++](https://img.shields.io/badge/G++-14.2.0-blue) ![Python](https://img.shields.io/badge/Python-3.11.2-blue) ![Nuitka](https://img.shields.io/badge/Nuitka-2.6.4-blue)
+![Arnelify Server for Python](https://img.shields.io/badge/Arnelify%20Server%20for%20Python-0.7.7-yellow) ![C++](https://img.shields.io/badge/C++-2b-red) ![G++](https://img.shields.io/badge/G++-14.2.0-blue) ![Python](https://img.shields.io/badge/Python-3.11.2-blue) ![Nuitka](https://img.shields.io/badge/Nuitka-2.6.4-blue)
 
 ## 🚀 About
 **Arnelify® Server for Python** - is a minimalistic dynamic library which is a powerful server written in C and C++.
@@ -73,7 +73,7 @@ This software is licensed under the <a href="https://github.com/arnelify/arnelif
 Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.
 
 ## ⭐ Release Notes
-Version 0.7.5 - Minimalistic dynamic library
+Version 0.7.7 - Minimalistic dynamic library
 
 We are excited to introduce the Arnelify Server dynamic library for Python! Please note that this version is raw and still in active development.
 

arnelify_server/index.py

@@ -46,43 +46,42 @@ def __init__(self, opts: dict):
 
       void server_http1_create(opts);
       void server_http1_destroy();
-      void server_http1_set_handler(cHandler cHandler, int hasRemove);
+      void server_http1_handler(cHandler cHandler);
       void server_http1_start(cCallback cCallback);
       void server_http1_stop();
     """)
 
-  def setHandler(self, handler: callable) -> None:
-    self.handler = handler
+  def handler(self, cb: callable) -> None:
+    self.callback = cb
 
-  def start(self, callback: callable) -> None:
+  def start(self, cb: callable) -> None:
     cOpts = self.ffi.new("char[]", self.opts.encode('utf-8'))
     self.lib.server_http1_create(cOpts)
 
-    if hasattr(self, 'handler'):
+    if hasattr(self, 'callback'):
       def handlerWrapper(cSerialized):
         serialized: str = self.ffi.string(cSerialized).decode('utf-8')
-        
         try: 
           json.loads(serialized)
         except json.JSONDecodeError as err:
           print("[Arnelify Server FFI]: Python error: The Request must be a valid JSON.")
           exit(1)
+
         req: dict = json.loads(serialized)
         res: Http1Res = Http1Res()
-
-        self.handler(req, res)
+        self.callback(req, res)
         serialized: str = res.serialize()
         return self.ffi.new("char[]", serialized.encode('utf-8'))
 
       self.cHandler = self.ffi.callback("const char* (const char*)", handlerWrapper)
-      self.lib.server_http1_set_handler(self.cHandler, 0)
+      self.lib.server_http1_handler(self.cHandler)
 
     def callbackWrapper(cMessage, isError):
       message: str = self.ffi.string(cMessage).decode('utf-8')
       if isError:
-        callback(message, True)
+        cb(message, True)
         return
-      callback(message, False)
+      cb(message, False)
 
     cCallback = self.ffi.callback("const void (const char*, const int)", callbackWrapper)
     def server_thread():

arnelify_server/src/addon.cpp

@@ -195,7 +195,7 @@ Napi::Value server_http1_create(const Napi::CallbackInfo& args) {
       json["SERVER_UPLOAD_DIR"].asString());
 
   http1 = new Http1(opts);
-  http1->setHandler([](const Http1Req& req, Http1Res res) {
+  http1->handler([](const Http1Req& req, Http1Res res) {
     std::promise<const std::string> promise;
     std::future<const std::string> future = promise.get_future();
     std::thread thread(

arnelify_server/src/ffi.cpp

@@ -158,22 +158,16 @@ void server_http1_create(const char *cOpts) {
 
 void server_http1_destroy() { http1 = nullptr; }
 
-void server_http1_set_handler(const char *(*cHandler)(const char *),
-                        const int hasRemove) {
-  http1->setHandler([cHandler, hasRemove](const Http1Req &req,
+void server_http1_handler(const char *(*cHandler)(const char *)) {
+  http1->handler([cHandler](const Http1Req &req,
                                            Http1Res res) -> void {
     Json::StreamWriterBuilder writer;
     writer["indentation"] = "";
     writer["emitUTF8"] = true;
 
     const std::string request = Json::writeString(writer, req);
     const char *cReq = request.c_str();
-    const char *cRes = cHandler(cReq);
-    if (cRes == nullptr) {
-      std::cout << "[ArnelifyServer FFI]: C error: cRes must be a valid JSON."
-                << std::endl;
-      exit(1);
-    }
+    std::string cRes = cHandler(cReq);
 
     Json::Value json;
     Json::CharReaderBuilder reader;
@@ -185,7 +179,7 @@ void server_http1_set_handler(const char *(*cHandler)(const char *),
       exit(1);
     }
 
-    if (hasRemove == 1) delete[] cRes;
+    cRes.clear();
     const bool hasCode = json.isMember("code");
     if (hasCode) {
       res->setCode(json["code"].asInt());

arnelify_server/src/tcp1/http1/index.h

@@ -23,10 +23,13 @@ class Http1 {
   bool isRunning;
   int serverSocket;
 
-  Http1IO *io;
+  Http1IO *asyncRead;
+  Http1IO *asyncHandler;
+  Http1IO *asyncWrite;
+
   const Http1Opts opts;
 
-  Http1Handler handler = [](const Http1Req &req, Http1Res res) -> void {
+  Http1Handler cb = [](const Http1Req &req, Http1Res res) -> void {
     Json::StreamWriterBuilder writer;
     writer["indentation"] = "";
     writer["emitUTF8"] = true;
@@ -52,16 +55,19 @@ class Http1 {
   Http1(Http1Opts &o) : isRunning(false), opts(o), serverSocket(0) {
     const int threadLimit =
         this->opts.HTTP1_THREAD_LIMIT > 0 ? this->opts.HTTP1_THREAD_LIMIT : 1;
-    this->io = new Http1IO(threadLimit);
+    this->asyncRead = new Http1IO(threadLimit);
+    this->asyncHandler = new Http1IO(threadLimit);
+    this->asyncWrite = new Http1IO(threadLimit);
   }
 
   ~Http1() {
     this->stop();
-    this->io->stop();
-    if (this->io != nullptr) delete this->io;
+    if (this->asyncRead) delete this->asyncRead;
+    if (this->asyncHandler) delete this->asyncHandler;
+    if (this->asyncWrite) delete this->asyncWrite;
   }
 
-  void setHandler(const Http1Handler &handler) { this->handler = handler; }
+  void handler(const Http1Handler &cb) { this->cb = cb; }
 
   void start(const Http1Logger &logger) {
     this->isRunning = true;
@@ -113,28 +119,27 @@ class Http1 {
       exit(1);
     }
 
-    this->io->onRead([this](Http1Task *task) {
-      ssize_t bytesRead = 0;
-      const std::size_t BLOCK_SIZE = this->opts.HTTP1_BLOCK_SIZE_KB * 1024;
-      char *block = new char[BLOCK_SIZE];
-      int SIGNAL_ON_BLOCK = 0;
-      while ((bytesRead = recv(task->clientSocket, block, BLOCK_SIZE, 0)) > 0) {
-        if (bytesRead == EWOULDBLOCK) {
-          delete[] block;
+    this->asyncRead->handler([this](Http1Task *task) {
+      const std::size_t blockLen = this->opts.HTTP1_BLOCK_SIZE_KB * 1024;
+      char *block = new char[blockLen];
+      int ON_RECEIVER = 0;
 
-          this->io->addRead(task);
+      while (!ON_RECEIVER) {
+        const ssize_t bytesRead = recv(task->clientSocket, block, blockLen, 0);
+        if (bytesRead == -1 && (errno == EWOULDBLOCK || errno == EAGAIN)) {
+          delete[] block;
+          this->asyncRead->addTask(task);
           return;
         }
 
-        SIGNAL_ON_BLOCK = task->receiver->onBlock(block, bytesRead);
-        if (SIGNAL_ON_BLOCK > 0) break;
+        ON_RECEIVER = task->receiver->onBlock(block, bytesRead);
       }
 
       delete[] block;
 
-      const bool isFinish = SIGNAL_ON_BLOCK == 2;
+      const bool isFinish = ON_RECEIVER == 2;
       if (isFinish) {
-        this->io->addHandler(task);
+        this->asyncHandler->addTask(task);
         return;
       }
 
@@ -151,21 +156,21 @@ class Http1 {
       task->transmitter->addBody(body);
       task->transmitter->end();
 
-      this->io->addWrite(task);
+      this->asyncWrite->addTask(task);
     });
 
-    this->io->onHandler([this](Http1Task *task) {
+    this->asyncHandler->handler([this](Http1Task *task) {
       task->transmitter->setLogger(this->logger);
       const std::string encoding = task->receiver->getEncoding();
       task->transmitter->setEncoding(encoding);
       const Http1Req req = task->receiver->finish();
       delete task->receiver;
 
-      this->handler(req, task->transmitter);
-      this->io->addWrite(task);
+      this->cb(req, task->transmitter);
+      this->asyncWrite->addTask(task);
     });
 
-    this->io->onWrite([](Http1Task *task) {
+    this->asyncWrite->handler([this](Http1Task *task) {
       task->transmitter->onWrite(
           [task](const char *block, const int bytesRead) {
             send(task->clientSocket, block, bytesRead, 0);
@@ -175,9 +180,6 @@ class Http1 {
       delete task;
     });
 
-    const std::string port = std::to_string(this->opts.HTTP1_PORT);
-    this->logger("Server is running on port " + port, false);
-
     sockaddr_in clientAddr;
     socklen_t clientLen = sizeof(clientAddr);
     const Http1TaskOpts opts(
@@ -187,6 +189,12 @@ class Http1 {
         this->opts.HTTP1_MAX_FIELDS_SIZE_TOTAL_MB, this->opts.HTTP1_MAX_FILES,
         this->opts.HTTP1_MAX_FILES_SIZE_TOTAL_MB,
         this->opts.HTTP1_MAX_FILE_SIZE_MB, this->opts.HTTP1_UPLOAD_DIR);
+    const std::string port = std::to_string(this->opts.HTTP1_PORT);
+    this->logger("Server is running on port " + port, false);
+
+    this->asyncRead->start();
+    this->asyncHandler->start();
+    this->asyncWrite->start();
 
     while (true) {
       const bool isStop = !this->isRunning;
@@ -206,15 +214,20 @@ class Http1 {
         continue;
       }
 
+      // int clientFlags = fcntl(clientSocket, F_GETFL, 0);
+      // if (clientFlags == -1 ||
+      //     fcntl(clientSocket, F_SETFL, clientFlags | O_NONBLOCK) == -1) {
+      //   this->logger("Failed to set client socket non-blocking", true);
+      //   close(clientSocket);
+      //   continue;
+      // }
+
       Http1Task *task = new Http1Task(clientSocket, opts);
-      this->io->addRead(task);
+      this->asyncRead->addTask(task);
     }
   }
 
-  void stop() {
-    this->io->stop();
-    this->isRunning = false;
-  }
+  void stop() { this->isRunning = false; }
 };
 
 #endif