UPD | wait all packets

Author: xiadnoring

main.cpp

@@ -1,47 +1,34 @@
+#include <iostream>
+
 #include <ManapiHttp.hpp>
 #include <ManapiInitTools.hpp>
 
-int main () {
-    /* creates 2 threads for blocking I/O syscalls */
-    manapi::async::context::threadpoolfs(2);
-    /* disable several signals */
-    manapi::async::context::gbs (manapi::async::context::blockedsignals());
-    /* creates 4 additional threads for 4 additional event loops */
-    auto ctx = manapi::async::context::create(4).unwrap();
-    /* HTTP context for multiple HTTP routers (threadsafe) */
-    auto router_ctx = manapi::net::http::server_ctx::create().unwrap();
-    /* runs main event loop and 4 additional event loops */
-    ctx->run(4, [router_ctx] (std::function<void()> bind) -> void {
-        using http = manapi::net::http::server;
+#define FOLDER "/home/Timur/Downloads/anime-main/"
+int main() {
+    manapi::init_tools::log_trace_init(manapi::debug::LOG_TRACE_HARD);
 
-        auto router = manapi::net::http::server::create(router_ctx).unwrap();
+    manapi::async::context::threadpoolfs(4);
+    manapi::async::context::gbs(manapi::async::context::blockedsignals());
 
-        router.GET("/[test]/+custom", [] (http::req &req, http::uresp resp) mutable -> void {
-            resp->text(std::format("{}, test={}", std::string{req.url()}, req.param("test").unwrap()));
-        }).unwrap();
+    auto ctx = manapi::async::context::create(0).unwrap();
 
-        router.GET("/user/[zone]-[id]", [] (http::req &req, http::uresp resp) mutable -> void {
-            resp->text(std::format("zone={} id={}", req.param("zone").unwrap(),
-                req.param("id").unwrap())).unwrap();
+    auto server_ctx = manapi::net::http::server_ctx::create().unwrap();
+    ctx->run(0, [server_ctx] (auto cb) -> void {
+        using http = manapi::net::http::server;
+        auto route = manapi::net::http::server::create(server_ctx).unwrap();
+
+        route.GET ("/", [] (http::req &req, http::uresp resp) -> void {
+            resp->file (manapi::filesystem::path::join(FOLDER, "index.html")).unwrap();
         }).unwrap();
 
-        manapi::async::run([router] () mutable -> manapi::future<> {
-            manapi::unwrap(co_await router.config_object({
-                {"pools", manapi::json::array({
-                    {
-                        {"address", "127.0.0.1"},
-                        {"http", manapi::json::array({"1.1"})},
-                        {"port", "8888"}
-                    }
-                })},
-                {"save_config", false}
-            }));
-
-            manapi::unwrap(co_await router.start());
+        route.GET ("/", FOLDER).unwrap();
+
+        manapi::async::run ([route] () mutable -> manapi::future<> {
+            manapi::unwrap(co_await route.config(manapi::filesystem::path::join(".", "config.json")));
+            manapi::unwrap(co_await route.start ());
         });
 
-        /* bind event loop in the current context */
-        bind();
+        cb();
     }).unwrap();
 
     manapi::clear_tools::curl_library_clear();

src/worker/ManapiTcp.cpp

@@ -393,7 +393,19 @@ void manapi::net::worker::TCP::close_connection(shared_conn conn, int flags) MAN
         conn->wrk.flags |= WRK_INTERFACE_IS_DRAINING;
         connection->flags |= CONN_RECV_END;
 
-        if (!connection->t && !(connection->flags & CONN_READ)) {
+        if (connection->flags == CLOSE_CONN_EOR) {
+            if (!connection->t && !(connection->flags & CONN_READ)) {
+                return;
+            }
+        }
+    }
+
+    if (flags & CLOSE_CONN_FINISHED) {
+        connection->flags |= CONN_RECV_END;
+        connection->flags |= CONN_SEND_END;
+
+        if (connection->top->cur_send_size != connection->top->send_size) {
+            // wait
             return;
         }
     }
@@ -795,15 +807,26 @@ int manapi::net::worker::TCP::flush_write_(const worker::shared_conn &connection
                                         manapi_log_trace(manapi::debug::LOG_TRACE_LOW, "write failed msg=%s %p conn",
                                             ev::strerror(status), connection.get());
                                         conn->worker->close_connection(connection, CLOSE_CONN_EOS);
+                                        return;
                                     }
-                                    else {
-                                        if ((conn->flags & (ev::WRITE|ev::DISCONNECT)) == ev::WRITE && conn->ev_callback) {
-                                            if (base::call_user_callback(&conn->ev_callback, connection, ev::WRITE, nullptr, 0, nullptr))
-                                                conn->worker->close_connection(connection, CLOSE_CONN_ERR);
+
+                                    if ((conn->flags & (ev::WRITE|ev::DISCONNECT)) == ev::WRITE && conn->ev_callback) {
+                                        if (base::call_user_callback(&conn->ev_callback, connection, ev::WRITE, nullptr, 0, nullptr)) {
+                                            conn->worker->close_connection(connection, CLOSE_CONN_ERR);
+                                            return;
                                         }
+                                    }
+
+                                    if (conn->flags & ev::DISCONNECT) {
+                                        conn->worker->close_connection(connection, CLOSE_CONN_SHUTDOWN);
+                                        return;
+                                    }
 
-                                        if (conn->flags & ev::DISCONNECT)
-                                            conn->worker->close_connection(connection, CLOSE_CONN_SHUTDOWN);
+                                    if (conn->flags & CONN_SEND_END && conn->flags & CONN_RECV_END) {
+                                        manapi_log_trace(manapi::debug::LOG_TRACE_LOW, "packets were sent after the closing conn %p",
+                                            connection.get());
+                                        conn->worker->close_connection(connection, CLOSE_CONN_FINISHED);
+                                        return;
                                     }
 
                                 }, buffptr, nbuff /* nbuf */);