Init server from client

deerith_engine_client/CMakeLists.txt

@@ -7,14 +7,14 @@ pkg_check_modules(IMGUI REQUIRED imgui)
 
 add_library(DeerithClient)
 
-file(GLOB_RECURSE deerith_client_SOURCES
+file(GLOB_RECURSE deerith_SOURCES
     CONFIGURE_DEPENDS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp
 )
 
 target_sources(DeerithClient
     PRIVATE
-        ${deerith_client_SOURCES}
+        ${deerith_SOURCES}
 )
 
 target_include_directories(DeerithClient

deerith_engine_client/src/engine.cpp

@@ -1,4 +1,5 @@
 #include <deerith/engine.h>
+#include <deerith/core/log.h>
 #include <deerith/core/core.h>
 
 #include "network/network_internals.h"
@@ -10,12 +11,16 @@ namespace deerith
 
 void deerith::init_engine()
 {
-    init_deerith_core();
+    init_log("client");
     init_network();
+
+    deerith_info("init engine");
 }
 
 void deerith::shutdown_enigne()
 {
-    shutdown_deerith_core();
+    shutdown_executing_servers();
     shutdown_network();
+    deerith_info("shutdown engine");
+    shutdown_log();
 }

deerith_engine_client/src/graphics/primitives.cpp

@@ -42,8 +42,8 @@ void deerith::define_primitive_viewspace(glm::vec2 start_viewspace, glm::vec2 en
     float width = end_viewspace.x - start_viewspace.x;
     float height = end_viewspace.y - start_viewspace.y;
 
-    deerith_client_assert(width > 0, "define_primitive_viewspace width must be > 0");
-    deerith_client_assert(height > 0, "define_primitive_viewspace height must be > 0");
+    deerith_assert(width > 0, "define_primitive_viewspace width must be > 0");
+    deerith_assert(height > 0, "define_primitive_viewspace height must be > 0");
 
     glm::mat4 m_projection = glm::ortho(
         start_viewspace.x,
@@ -66,8 +66,8 @@ void deerith::draw_primitive_rectangle(glm::vec2 start, glm::vec2 end)
     float width = end.x - start.x;
     float height = end.y - start.y;
 
-    deerith_client_assert(width > 0, "draw_primitive_rectangle width must be > 0");
-    deerith_client_assert(height > 0, "draw_primitive_rectangle height must be > 0");
+    deerith_assert(width > 0, "draw_primitive_rectangle width must be > 0");
+    deerith_assert(height > 0, "draw_primitive_rectangle height must be > 0");
 
     glm::mat4 model = glm::translate(glm::mat4(1), glm::vec3(start.x, start.y, 0.0f));
     model = glm::scale(model, glm::vec3(width, height, 1.0f));

deerith_engine_client/src/network/network.cpp

@@ -19,20 +19,20 @@ void deerith::connect_to_server(const char *address, int port)
     eaddress.port = port;
 
     int result = enet_address_set_host(&eaddress, address);
-    deerith_client_assert(result == 0, "connect_to_server invalid address");
+    deerith_assert(result == 0, "connect_to_server invalid address");
 
     client = enet_host_create(NULL, 1, 2, 0, 0);
-    deerith_client_assert(client, "connect_to_server failed to create host");
+    deerith_assert(client, "connect_to_server failed to create host");
 
     client_peer = enet_host_connect(client, &eaddress, 2, 0);
-    deerith_client_assert(client_peer, "enet_host_connect failed on connect_to_server");
+    deerith_assert(client_peer, "enet_host_connect failed on connect_to_server");
 }
 
 int deerith::init_network()
 {
     if (enet_initialize() != 0)
     {
-        deerith_client_error("An error occurred while initializing ENet.\n");
+        deerith_error("An error occurred while initializing ENet.\n");
         return 1;
     }
 
@@ -49,7 +49,6 @@ void deerith::flush_network_events()
     ENetEvent event;
     while (enet_host_service(client, &event, 0) > 0)
     {
-        deerith_client_info("{}", (int)event.type);
     }
 }
 
@@ -59,7 +58,7 @@ bool deerith::wait_till_connected_to_server()
     if (enet_host_service(client, &event, 5000) > 0 &&
         event.type == ENET_EVENT_TYPE_CONNECT)
     {
-        deerith_client_info("Connected to server");
+        deerith_info("Connected to server");
 
         return true;
     }
@@ -67,7 +66,7 @@ bool deerith::wait_till_connected_to_server()
     else
     {
         enet_peer_reset(client_peer);
-        deerith_client_error("Failed to connect to server");
+        deerith_error("Failed to connect to server");
         return false;
     }
 }

deerith_engine_client/src/universe/universe.cpp

@@ -17,7 +17,7 @@ namespace deerith
 
 void deerith::begin_connection_to_universe(const char *address, int port)
 {
-    deerith_core_assert(!universe_running, "begin_connection_to_universe failed because there is a current running universe");
+    deerith_assert(!universe_running, "begin_connection_to_universe failed because there is a current running universe");
 
     if (universe_thread && universe_thread->joinable())
         universe_thread->join();
@@ -49,7 +49,7 @@ void deerith::universe_simulation()
         }
     }
 
-    deerith_client_trace("Thread stop");
+    deerith_trace("Thread stop");
     universe_running = false;
 }
 

deerith_engine_core/CMakeLists.txt

@@ -17,14 +17,14 @@ find_package(spdlog REQUIRED)
 find_package(fmt REQUIRED)
 find_package(glm REQUIRED)
 
-file(GLOB_RECURSE DEERITH_CORE_SOURCES
+file(GLOB_RECURSE deerith_SOURCES
     CONFIGURE_DEPENDS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp
 )
 
 target_sources(DeerithCore
     PRIVATE
-        ${DEERITH_CORE_SOURCES}
+        ${deerith_SOURCES}
 )
 
 target_include_directories(DeerithCore

deerith_engine_core/include/deerith/core/core.h

@@ -2,6 +2,5 @@
 
 namespace deerith
 {
-    int init_deerith_core();
-    void shutdown_deerith_core();
+
 }

deerith_engine_core/include/deerith/core/log.h

@@ -5,43 +5,20 @@
 
 namespace deerith
 {
-    spdlog::logger *get_core_logger();
-    spdlog::logger *get_graphics_logger();
-    spdlog::logger *get_server_logger();
+    void init_log(const char *);
+    void shutdown_log();
+
+    spdlog::logger *get_logger();
 } // namespace deerith
 
-#define deerith_core_trace(...) deerith::get_core_logger()->trace(__VA_ARGS__)
-#define deerith_core_info(...) deerith::get_core_logger()->info(__VA_ARGS__)
-#define deerith_core_warn(...) deerith::get_core_logger()->warn(__VA_ARGS__)
-#define deerith_core_error(...) deerith::get_core_logger()->error(__VA_ARGS__)
+#define deerith_trace(...) deerith::get_logger()->trace(__VA_ARGS__)
+#define deerith_info(...) deerith::get_logger()->info(__VA_ARGS__)
+#define deerith_warn(...) deerith::get_logger()->warn(__VA_ARGS__)
+#define deerith_error(...) deerith::get_logger()->error(__VA_ARGS__)
 
-#define deerith_server_trace(...) deerith::get_server_logger()->trace(__VA_ARGS__)
-#define deerith_server_info(...) deerith::get_server_logger()->info(__VA_ARGS__)
-#define deerith_server_warn(...) deerith::get_server_logger()->warn(__VA_ARGS__)
-#define deerith_server_error(...) deerith::get_server_logger()->error(__VA_ARGS__)
-
-#define deerith_client_trace(...) deerith::get_graphics_logger()->trace(__VA_ARGS__)
-#define deerith_client_info(...) deerith::get_graphics_logger()->info(__VA_ARGS__)
-#define deerith_client_warn(...) deerith::get_graphics_logger()->warn(__VA_ARGS__)
-#define deerith_client_error(...) deerith::get_graphics_logger()->error(__VA_ARGS__)
-
-#define deerith_core_assert(condition, ...)             \
+#define deerith_assert(condition, ...)             \
     if (!(condition))                              \
     {                                              \
-        deerith::get_core_logger()->error(__VA_ARGS__); \
-        __builtin_trap();                               \
-    }
-
-#define deerith_client_assert(condition, ...)               \
-    if (!(condition))                                       \
-    {                                                       \
-        deerith::get_graphics_logger()->error(__VA_ARGS__); \
-        __builtin_trap();                                   \
-    }
-
-#define deerith_server_assert(condition, ...)             \
-    if (!(condition))                                     \
-    {                                                     \
-        deerith::get_server_logger()->error(__VA_ARGS__); \
+        deerith::get_logger()->error(__VA_ARGS__); \
         __builtin_trap();                          \
     }

deerith_engine_core/include/deerith/engine.h

@@ -4,4 +4,7 @@ namespace deerith
 {
     void init_engine();
     void shutdown_enigne();
+
+    void execute_server(const char *server_executable_path, int port);
+    void shutdown_executing_servers();
 }

deerith_engine_core/src/core.cpp

@@ -1,14 +0,0 @@
-#include "deerith/core/core.h"
-#include "internal.h"
-
-int deerith::init_deerith_core()
-{
-    init_log();
-
-    return 0;
-}
-
-void deerith::shutdown_deerith_core()
-{
-    shutdown_log();
-}

deerith_engine_core/src/internal.h

@@ -2,7 +2,6 @@
 
 namespace deerith
 {
-    void init_log();
     void shutdown_log();
 
     void init_network();

deerith_engine_core/src/log.cpp

@@ -5,44 +5,25 @@
 
 namespace deerith
 {
-    std::shared_ptr<spdlog::logger> core_logger;
-    std::shared_ptr<spdlog::logger> graphics_logger;
-    std::shared_ptr<spdlog::logger> server_logger;
-
+    std::shared_ptr<spdlog::logger> logger;
 }
 
-void deerith::init_log()
+void deerith::init_log(const char *name)
 {
     spdlog::set_pattern("%^[%T] %n: %v%$");
 
-    core_logger = spdlog::stdout_color_mt("core");
-    graphics_logger = spdlog::stdout_color_mt("graphics");
-    server_logger = spdlog::stdout_color_mt("server");
-
-    core_logger->set_level(spdlog::level::level_enum::trace);
-    graphics_logger->set_level(spdlog::level::level_enum::trace);
-    server_logger->set_level(spdlog::level::level_enum::trace);
+    logger = spdlog::stdout_color_mt(name);
+    logger->set_level(spdlog::level::level_enum::trace);
 }
 
 void deerith::shutdown_log()
 {
-    core_logger.reset();
-    graphics_logger.reset();
+    logger.reset();
 
     spdlog::drop_all();
 }
 
-spdlog::logger *deerith::get_core_logger()
+spdlog::logger *deerith::get_logger()
 {
-    return core_logger.get();
-}
-
-spdlog::logger *deerith::get_graphics_logger()
-{
-    return graphics_logger.get();
-}
-
-spdlog::logger *deerith::get_server_logger()
-{
-    return server_logger.get();
+    return logger.get();
 }

deerith_engine_core/src/server_execution.cpp

@@ -0,0 +1,51 @@
+#include <deerith/engine.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include <deerith/core/log.h>
+#include <vector>
+
+#include <csignal>
+
+namespace deerith
+{
+    std::vector<pid_t> executing_servers;
+}
+
+void deerith::execute_server(const char *server_executable_path, int port)
+{
+    pid_t pid = fork();
+
+    if (pid < 0)
+    {
+        deerith_error("execute_server fatal error");
+    }
+
+    if (pid > 0)
+    {
+        executing_servers.push_back(pid);
+        deerith_info("server created");
+    }
+    else
+    {
+        execl(server_executable_path,
+              server_executable_path,
+              "-p",
+              "8080",
+              nullptr);
+
+        deerith_error("Fatal error executing server");
+        _exit(1);
+    }
+}
+
+void deerith::shutdown_executing_servers()
+{
+    for (pid_t pid : executing_servers)
+    {
+        kill(pid, SIGTERM);
+        waitpid(pid, nullptr, 0);
+    }
+
+    executing_servers.clear();
+}

deerith_engine_server/CMakeLists.txt

@@ -1,13 +1,13 @@
 add_library(DeerithServer)
 
-file(GLOB_RECURSE deerith_server_SOURCES
+file(GLOB_RECURSE deerith_SOURCES
     CONFIGURE_DEPENDS
     ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp
 )
 
 target_sources(DeerithServer
     PRIVATE
-        ${deerith_server_SOURCES}
+        ${deerith_SOURCES}
 )
 
 target_include_directories(DeerithServer

deerith_engine_server/src/core.cpp

@@ -1,6 +1,8 @@
 #include <deerith/engine.h>
 #include <deerith/core/core.h>
 
+#include <deerith/core/log.h>
+
 #include "network/network_internals.h"
 
 namespace deerith
@@ -10,12 +12,16 @@ namespace deerith
 
 void deerith::init_engine()
 {
-    init_deerith_core();
+    init_log("server");
     init_network();
+
+    deerith_info("init server engine");
 }
 
 void deerith::shutdown_enigne()
 {
     shutdown_network();
-    shutdown_deerith_core();
+
+    deerith_info("shutdown server engine");
+    shutdown_log();
 }

deerith_engine_server/src/network/network.cpp

@@ -15,7 +15,7 @@ namespace deerith
     std::vector<ENetPeer *> new_clients;
 }
 
-void deerith::init_server(int port)
+bool deerith::init_server(int port)
 {
     ENetAddress address = {0};
 
@@ -24,14 +24,19 @@ void deerith::init_server(int port)
 
     server = enet_host_create(&address, 32, 2, 0, 0);
 
-    deerith_server_assert(server, "init_server failed");
+    if (server == nullptr)
+    {
+        deerith_error("init_server failed");
+        return false;
+    }
+    return true;
 }
 
 int deerith::init_network()
 {
     if (enet_initialize() != 0)
     {
-        deerith_client_error("An error occurred while initializing ENet.\n");
+        deerith_error("An error occurred while initializing ENet.\n");
         return 1;
     }
 
@@ -80,5 +85,4 @@ void deerith::flush_network_events()
             break;
         }
     }
-    deerith_server_info("{} ", result);
 }

deerith_engine_server/src/network/network_internals.h

@@ -7,7 +7,7 @@ namespace deerith
     int init_network();
     void shutdown_network();
 
-    void init_server(int port);
+    bool init_server(int port);
     void flush_network_events();
 
     std::vector<ENetPeer *> &get_new_clients();

deerith_engine_server/src/universe.cpp

@@ -5,22 +5,40 @@
 #include <deerith/core/log.h>
 #include "network/network_internals.h"
 
+#include <csignal>
+#include <atomic>
+
 namespace deerith
 {
     int universe_tick = 0;
     void universe_simulation();
 
+    std::atomic<bool> running = true;
+
     void create_client(ENetPeer *peer);
+    void handle_signal(int signal);
+}
+
+void deerith::handle_signal(int signal)
+{
+    if (signal == SIGTERM)
+        running = false;
 }
 
 void deerith::begin_universe(int port)
 {
-    init_server(port);
-    while (true)
+    std::signal(SIGTERM, handle_signal);
+
+    bool init_result = init_server(port);
+
+    if (init_result)
+    {
+        while (running)
         {
             universe_simulation();
         }
     }
+}
 
 void deerith::universe_simulation()
 {
@@ -42,5 +60,5 @@ void deerith::create_client(ENetPeer *client)
 {
     char enet_address[32];
     enet_address_get_host_ip(&client->address, enet_address, 31);
-    deerith_server_info("A new client has connected : {}", enet_address);
+    deerith_info("A new client has connected : {}", enet_address);
 }

sandbox/src/client/window.cpp

@@ -16,7 +16,7 @@ float vel = 1;
 
 void start_window_loop()
 {
-    deerith_client_assert(deerith::init_window() == 0, "Failed to init_window");
+    deerith_assert(deerith::init_window() == 0, "Failed to init_window");
 
     while (deerith::begin_window_display())
     {
@@ -44,6 +44,16 @@ void start_window_loop()
                 {
                     deerith::begin_connection_to_universe(net_address, port);
                 }
+
+                if (ImGui::Button("Create server"))
+                {
+                    deerith::execute_server("./SandboxServer", 8080);
+                }
+
+                if (ImGui::Button("Close all servers"))
+                {
+                    deerith::shutdown_executing_servers();
+                }
             }
         }
         ImGui::End();

sandbox/src/server/server.cpp

@@ -1,7 +1,10 @@
 #include <deerith/universe.h>
-
 #include "server/server.h"
 
+namespace deerith
+{
+}
+
 void init_server()
 {
     deerith::begin_universe(8085);