feat(ui): implement discovery page

.vscode/c_cpp_properties.json

@@ -0,0 +1,17 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/clang",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "linux-clang-x64",
+            "compileCommands": "${workspaceFolder}/out/build/Unix-Makefiles-Default/compile_commands.json"
+        }
+    ],
+    "version": 4
+}

.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+    "configurations": [
+        {
+            "type": "cmake",
+            "request": "launch",
+            "name": "Debug portfile(s)",
+            "cmakeDebugType": "external",
+            "pipeName": "/tmp/vcpkg_ext_portfile_dbg",
+            "preLaunchTask": "Debug vcpkg commands"
+        }
+    ]
+}

CMakeLists.txt

@@ -16,7 +16,9 @@ if (POLICY CMP0167)
 endif()
 
 project(sast-evento VERSION ${VERSION_SEMANTIC} LANGUAGES CXX)
-option(EVENTO_EMBED_RESOURCES "ON to request slint embed resources")
+
+option(EVENTO_EMBED_RESOURCES OFF "Request slint embed resources")
+set(SLINT_STYLE "material" CACHE STRING "Slint style" FORCE)
 
 if(APPLE)
   set(MACOSX_BUNDLE_GUI_IDENTIFIER ${IDENTIFIER})

CMakePresets.json

@@ -59,6 +59,29 @@
                 "value": "arm64",
                 "strategy": "external"
             }
+        },
+        {
+            "name": "Clang-Default",
+            "hidden": true,
+            "displayName": "Clang 17.0.6 x86_64-pc-linux-gnu",
+            "description": "使用编译器: C = /usr/bin/clang, CXX = /usr/bin/clang++",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
+                "CMAKE_C_COMPILER": "/usr/bin/clang",
+                "CMAKE_CXX_COMPILER": "/usr/bin/clang++",
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+        {
+            "name": "Unix-Makefiles-Default",
+            "description": "Config with Unix Makefile",
+            "displayName": "Unix-Makefiles-Default",
+            "inherits": [
+                "Clang-Default"
+            ],
+            "generator": "Unix Makefiles",
+            "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
         }
     ],
     "buildPresets": [

src/Controller/AsyncExecutor.hh

@@ -1,20 +1,20 @@
 #pragma once
 
+#include <bitset>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/co_spawn.hpp>
 #include <boost/asio/experimental/awaitable_operators.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/signal_set.hpp>
+#include <boost/asio/static_thread_pool.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/system/detail/error_code.hpp>
 #include <chrono>
 #include <memory>
 #include <slint.h>
 #include <spdlog/spdlog.h>
 #include <thread>
-#include <unordered_map>
 #include <utility>
-#include <vector>
 
 using namespace boost::asio::experimental::awaitable_operators;
 
@@ -30,12 +30,21 @@ public:
     AsyncExecutor(const AsyncExecutor&) = delete;
     AsyncExecutor& operator=(const AsyncExecutor&) = delete;
 
+    enum TimerFlag {
+        Immediate = 1,
+        Delay = 1 << 1,
+        Once = 1 << 2,
+        Periodic = 1 << 3,
+    };
+
     /**
-     * @param task:      return value of a coroutine,
+     * @brief            execute a coroutine and call the callback when it's done
+     *
+     * @param task       return value of a coroutine,
      *                   an awaitable object wrapping a T type value
      *
-     * @param callback:  callback function, called in the main thread when coroutine is done
-     *                   parameter: any based on T except T&&   
+     * @param callback   callback function, called in the main thread when coroutine is done
+     *                   parameter: any based on T(awaitable object wrapped type) except T&&   
     */
     template<typename T, BOOST_ASIO_COMPLETION_TOKEN_FOR(void(T&)) CompletionCallback>
     void asyncExecute(Task<T> task, CompletionCallback&& callback) {
@@ -59,10 +68,12 @@ public:
     }
 
     /**
-     * @param task:      return value of a coroutine, 
+     * @brief            execute a coroutine and call the callback when it's done
+     *
+     * @param task       return value of a coroutine, 
      *                   an awaitable object wrapping a T type value
      *
-     * @param callback:  callback function, called in the main thread when coroutine is done
+     * @param callback   callback function, called in the main thread when coroutine is done
      *                   parameter: void
      *
      * Specialization for "void"
@@ -85,23 +96,46 @@ public:
     }
 
     /**
-     * @param func:      coroutine function pointer
+     * @brief            execute a coroutine and call the callback when it's done at specific intervals using a timer
+     *
+     * @param func       coroutine function pointer
      *
-     * @param callback:  callback function, called in the main thread when coroutine is done periodically
-     *                   parameters: any based on T(awaitable object wrapped type) except T&&
+     * @param callback   callback function, called in the main thread when coroutine is done periodically
+     *                   parameter: any based on T(awaitable object wrapped type) except T&&
      *
-     * @param interval:  interval between each coroutine call
+     * @param interval   interval between each coroutine call
+     * 
+     * @param flag       the strategy of the timer, MUST use `|` to combine two enum values below:
+     *                   * Immediate: execute the coroutine immediately
+     *                   * Delay: execute the coroutine after the interval
+     *                   * Once: execute the coroutine once
+     *                   * Periodic: execute the coroutine every interval periodically
+     *
+     *                   FORBIDDEN combinations:
+     *                   * Immediate and Delay
+     *                   * Periodic and Once
      */
     template<typename TaskFunc, typename CompletionCallback>
     void asyncExecute(TaskFunc&& func,
                       CompletionCallback&& callback,
-                      std::chrono::steady_clock::duration interval) {
-        asyncExecute(func(), callback);
-        asyncExecuteByTimer(std::forward<TaskFunc>(func),
-                            std::forward<CompletionCallback>(callback),
-                            interval);
+                      std::chrono::steady_clock::duration interval,
+                      int flag = TimerFlag::Periodic | TimerFlag::Immediate) {
+        assert(std::bitset<32>(flag).count() == 2);
+        assert(!(flag & TimerFlag::Immediate && flag & TimerFlag::Delay));
+        assert(!(flag & TimerFlag::Periodic && flag & TimerFlag::Once));
+
+        if (flag & TimerFlag::Immediate)
+            asyncExecute(func(), callback);
+
+        if (flag & TimerFlag::Periodic || flag & TimerFlag::Delay)
+            asyncExecuteByTimer(std::forward<TaskFunc>(func),
+                                std::forward<CompletionCallback>(callback),
+                                interval,
+                                flag);
     }
 
+    net::io_context& getIoContext() { return _ioc; }
+
     ~AsyncExecutor() {
         _ioc.stop();
         if (_iocThread.joinable()) {
@@ -125,26 +159,19 @@ private:
     }
 
     template<typename TaskFunc, typename CompletionCallback>
+        requires std::is_invocable_v<CompletionCallback>
     void asyncExecuteByTimer(TaskFunc&& func,
                              CompletionCallback&& callback,
-                             std::chrono::steady_clock::duration interval) {
-        _periodicTasks[_taskId] = interval;
+                             std::chrono::steady_clock::duration interval,
+                             int flag) {
         auto timer = std::make_shared<net::steady_timer>(_ioc, interval);
-        _timers.push_back(timer);
-        asyncExecuteByTimerHelper(std::forward<TaskFunc>(func),
-                                  std::forward<CompletionCallback>(callback),
-                                  _taskId);
-        ++_taskId;
-    }
-
-    template<typename TaskFunc, typename CompletionCallback>
-        requires std::is_invocable_v<CompletionCallback>
-    void asyncExecuteByTimerHelper(TaskFunc&& func, CompletionCallback&& callback, int taskId) {
-        _timers[taskId]->async_wait([=,
-                                     func = std::forward<TaskFunc>(func),
-                                     callback = std::forward<CompletionCallback>(callback),
-                                     this](const boost::system::error_code& ec) {
+        timer->async_wait([=,
+                           func = std::forward<TaskFunc>(func),
+                           callback = std::forward<CompletionCallback>(callback),
+                           this](const boost::system::error_code& ec) {
             if (!ec) {
+                // ensure timer is captured
+                timer.get();
                 net::co_spawn(_ioc, func(), [callback](std::exception_ptr e) {
                     if (!e) {
                         slint::invoke_from_event_loop(callback);
@@ -156,8 +183,9 @@ private:
                         spdlog::error(ex.what());
                     }
                 });
-                _timers[taskId]->expires_after(_periodicTasks[taskId]);
-                asyncExecuteByTimerHelper(std::move(func), std::move(callback), taskId);
+                if (flag & TimerFlag::Periodic) {
+                    asyncExecuteByTimer(std::move(func), std::move(callback), interval, flag);
+                }
             } else {
                 spdlog::error(ec.what());
             }
@@ -166,12 +194,18 @@ private:
 
     template<typename TaskFunc, typename CompletionCallback>
         requires(!std::is_same_v<net::awaitable<void>, std::invoke_result_t<TaskFunc>>)
-    void asyncExecuteByTimerHelper(TaskFunc&& func, CompletionCallback&& callback, int taskId) {
-        _timers[taskId]->async_wait([=,
-                                     func = std::forward<TaskFunc>(func),
-                                     callback = std::forward<CompletionCallback>(callback),
-                                     this](const boost::system::error_code& ec) {
+    void asyncExecuteByTimer(TaskFunc&& func,
+                             CompletionCallback&& callback,
+                             std::chrono::steady_clock::duration interval,
+                             int flag) {
+        auto timer = std::make_shared<net::steady_timer>(_ioc, interval);
+        timer->async_wait([=,
+                           func = std::forward<TaskFunc>(func),
+                           callback = std::forward<CompletionCallback>(callback),
+                           this](const boost::system::error_code& ec) {
             if (!ec) {
+                // ensure timer is captured
+                timer.get();
                 net::co_spawn(_ioc, func(), [callback](std::exception_ptr e, auto value) {
                     if (!e) {
                         slint::invoke_from_event_loop(
@@ -186,8 +220,9 @@ private:
                         spdlog::error(ex.what());
                     }
                 });
-                _timers[taskId]->expires_after(_periodicTasks[taskId]);
-                asyncExecuteByTimerHelper(std::move(func), std::move(callback), taskId);
+                if (flag & TimerFlag::Periodic) {
+                    asyncExecuteByTimer(std::move(func), std::move(callback), interval, flag);
+                }
             } else {
                 spdlog::error(ec.what());
             }
@@ -197,9 +232,6 @@ private:
 private:
     net::io_context _ioc;
     std::thread _iocThread;
-    std::vector<std::shared_ptr<net::steady_timer>> _timers;
-    std::unordered_map<int, std::chrono::steady_clock::duration> _periodicTasks;
-    int _taskId = 0;
 
     friend AsyncExecutor* executor();
 };