Added more tests, Optimize tests, Refactor reload impl (#5764)

* Added tests --filter=[core]

* Update core.yml --filter=[core]

* Update core.yml --filter=[core]

* Refactor reload impl --filter=[core]

Author: matyhtf

.github/workflows/core.yml

@@ -64,8 +64,8 @@ jobs:
       - name: run coverage
         shell: bash
         run: sudo apt-get install lcov &&
-          sudo lcov --directory . --capture --output-file coverage.info &&
-          sudo lcov --remove coverage.info "${{runner.workspace}}/swoole-src/include/*" '/usr/*' --output-file coverage.info &&
+          sudo lcov --directory . --capture --branch-coverage --rc geninfo_unexecuted_blocks=1 --ignore-errors mismatch --output-file coverage.info &&
+          sudo lcov --remove coverage.info '/usr/*' --output-file coverage.info &&
           sudo lcov --list coverage.info
 
       - name: Upload coverage to Codecov

core-tests/code-stats.sh

@@ -0,0 +1,7 @@
+#!/bin/sh -e
+__CURRENT__=$(pwd)
+__DIR__=$(cd "$(dirname "$0")";pwd)
+
+# enter the dir
+cd "${__DIR__}"
+cloc . --exclude-dir=js,Debug,CMakeFiles,build,CMakeFiles,deps

core-tests/include/test_core.h

@@ -54,6 +54,8 @@
 #define ASSERT_MEMEQ(x, y, n) ASSERT_EQ(memcmp((x), (y), n), 0)
 #define EXPECT_MEMEQ(x, y, n) EXPECT_EQ(memcmp((x), (y), n), 0)
 
+#define TIMER_PARAMS Timer *timer, TimerNode *tnode
+
 namespace swoole {
 struct HttpProxy;
 struct Socks5Proxy;

core-tests/src/coroutine/socket.cpp

@@ -51,7 +51,19 @@ TEST(coroutine_socket, connect_refused) {
 TEST(coroutine_socket, connect_timeout) {
     coroutine::run([](void *arg) {
         Socket sock(SW_SOCK_TCP);
+
         sock.set_timeout(0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_DNS), 0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_CONNECT), 0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_READ), 0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_WRITE), 0.5);
+
+        sock.set_timeout(1.5, Socket::TIMEOUT_RDWR);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_DNS), 0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_CONNECT), 0.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_READ), 1.5);
+        ASSERT_EQ(sock.get_timeout(Socket::TIMEOUT_WRITE), 1.5);
+
         bool retval = sock.connect("192.0.0.1", 9801);
         ASSERT_EQ(retval, false);
         ASSERT_EQ(sock.errCode, ETIMEDOUT);
@@ -769,6 +781,27 @@ TEST(coroutine_socket, getsockname) {
     });
 }
 
+TEST(coroutine_socket, buffer) {
+    Socket sock(SW_SOCK_TCP);
+    auto rbuf = sock.get_read_buffer();
+    auto wbuf = sock.get_write_buffer();
+
+    auto rbuf_pop = sock.pop_read_buffer();
+    auto wbuf_pop = sock.pop_write_buffer();
+
+    ASSERT_EQ(rbuf, rbuf_pop);
+    ASSERT_EQ(wbuf, wbuf_pop);
+
+    auto rbuf2 = sock.get_read_buffer();
+    auto wbuf2 = sock.get_write_buffer();
+
+    ASSERT_NE(rbuf2, rbuf);
+    ASSERT_NE(wbuf2, wbuf);
+
+    delete rbuf_pop;
+    delete wbuf_pop;
+}
+
 TEST(coroutine_socket, check_liveness) {
     coroutine::run([](void *arg) {
         Socket sock(SW_SOCK_TCP);
@@ -1298,3 +1331,9 @@ TEST(coroutine_socket, cancel) {
         ASSERT_TRUE(results["read"]);
     });
 }
+
+TEST(coroutine_socket, get_event_str) {
+    Socket sock;
+    ASSERT_STREQ(sock.get_event_str(SW_EVENT_READ), "reading");
+    ASSERT_STREQ(sock.get_event_str(SW_EVENT_WRITE), "writing");
+}

core-tests/src/os/process_pool.cpp

@@ -176,6 +176,47 @@ TEST(process_pool, shutdown) {
     sysv_signal(SIGTERM, SIG_DFL);
 }
 
+TEST(process_pool, reload) {
+    ProcessPool pool{};
+    int *shm_value = (int *) sw_mem_pool()->alloc(sizeof(int));
+    ASSERT_EQ(pool.create(2), SW_OK);
+
+    // init
+    pool.set_max_packet_size(8192);
+    pool.ptr = shm_value;
+    pool.max_wait_time = 1;
+
+    pool.onWorkerStart = [](ProcessPool *pool, Worker *worker) {
+        int *shm_value = (int *) pool->ptr;
+        (*shm_value)++;
+
+        sysv_signal(SIGTERM, SIG_IGN);
+
+        while (true) {
+            sleep(10000);
+        }
+    };
+
+    pool.onStart = [](ProcessPool *pool) { swoole_timer_after(100, [pool](TIMER_PARAMS) { pool->reload(); }); };
+
+    pool.onBeforeReload = [](ProcessPool *pool) { printf("onBeforeReload\n"); };
+
+    pool.onAfterReload = [](ProcessPool *pool) {
+        printf("onAfterReload\n");
+        swoole_timer_after(100, [pool](TIMER_PARAMS) { pool->shutdown(); });
+    };
+
+    current_pool = &pool;
+    sysv_signal(SIGTERM, [](int sig) { current_pool->running = false; });
+
+    ASSERT_EQ(pool.start(), SW_OK);
+    ASSERT_EQ(pool.wait(), SW_OK);
+
+    pool.destroy();
+
+    ASSERT_EQ(*shm_value, 4);
+}
+
 TEST(process_pool, async) {
     ProcessPool pool{};
     ASSERT_EQ(pool.create(1, 0, SW_IPC_UNIXSOCK), SW_OK);

ext-src/swoole_process_pool.cc

@@ -308,7 +308,6 @@ static void process_pool_signal_handler(int sig) {
     case SIGUSR1:
     case SIGUSR2:
         current_pool->reload();
-        current_pool->reload_init = false;
         break;
     case SIGIO:
         current_pool->read_message = true;

include/swoole_coroutine.h

@@ -144,13 +144,7 @@ class Coroutine {
     static void set_on_resume(SwapCallback func);
     static void set_on_close(SwapCallback func);
     static void bailout(BailoutCallback func);
-
-    static inline bool run(const CoroutineFunc &fn, void *args = nullptr) {
-        swoole_event_init(SW_EVENTLOOP_WAIT_EXIT);
-        long cid = create(fn, args);
-        swoole_event_wait();
-        return cid > 0;
-    }
+    static bool run(const CoroutineFunc &fn, void *args = nullptr);
 
     static inline long create(const CoroutineFunc &fn, void *args = nullptr) {
 #ifdef SW_USE_THREAD_CONTEXT
@@ -228,17 +222,7 @@ class Coroutine {
         return sw_likely(co) ? co->get_execute_usec() : -1;
     }
 
-    static inline void calc_execute_usec(Coroutine *yield_coroutine, Coroutine *resume_coroutine) {
-        long current_usec = time<seconds_type>(true);
-        if (yield_coroutine) {
-            yield_coroutine->execute_usec += current_usec - yield_coroutine->switch_usec;
-        }
-
-        if (resume_coroutine) {
-            resume_coroutine->switch_usec = current_usec;
-        }
-    }
-
+    static void calc_execute_usec(Coroutine *yield_coroutine, Coroutine *resume_coroutine);
     static void print_list();
 
   protected:
@@ -263,41 +247,9 @@ class Coroutine {
     Coroutine *origin = nullptr;
     CancelFunc *cancel_fn_ = nullptr;
 
-    Coroutine(const CoroutineFunc &fn, void *private_data) : ctx(stack_size, fn, private_data) {
-        cid = ++last_cid;
-        coroutines[cid] = this;
-        if (sw_unlikely(count() > peak_num)) {
-            peak_num = count();
-        }
-        if (!activated) {
-            activate();
-        }
-    }
-
-    Coroutine(long _cid, const CoroutineFunc &fn, void *private_data) : ctx(stack_size, fn, private_data) {
-        cid = _cid;
-    }
-
-    long run() {
-        long cid = this->cid;
-        origin = current;
-        current = this;
-        CALC_EXECUTE_USEC(origin, nullptr);
-        state = STATE_RUNNING;
-        ctx.swap_in();
-        check_end();
-        return cid;
-    }
-
-    void check_end() {
-        if (ctx.is_end()) {
-            close();
-        } else if (sw_unlikely(on_bailout)) {
-            SW_ASSERT(current == nullptr);
-            on_bailout();
-        }
-    }
-
+    Coroutine(const CoroutineFunc &fn, void *private_data);
+    long run();
+    void check_end();
     void close();
 };
 //-------------------------------------------------------------------------------