Merge pull request #8 from lichifeng/refactor-2024-linux

Modifications compiling on alpine. Add a static library option. Updated spdlog.

Author: lichifeng

.github/workflows/docker-publish.yml

@@ -18,9 +18,18 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME  }}
           password: ${{ secrets.DOCKERHUB_TOKEN  }}
 
-      - name: Build and push Docker image
+      - name: Build and push Docker image (default)
         uses: docker/build-push-action@v5
         with:
           context: .
           push: true
           tags: lichifeng/mgxparser:latest
+          file: Dockerfile
+
+      - name: Build and push Docker image (alpine)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: lichifeng/mgxparser:alpine
+          file: Dockerfile.alpine

CMakeLists.txt

@@ -5,7 +5,7 @@
 # Project info
 project(
         MgxParser
-        VERSION 0.5.0
+        VERSION 0.5.2
         LANGUAGES CXX
         HOMEPAGE_URL "https://github.com/lichifeng/MgxParser"
         DESCRIPTION "MgxParser is a C++ lib used to parse Age of Empires II game records."
@@ -17,6 +17,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_POSITION_INDEPENDENT_CODE true)
 set(USE_BM_SEARCH 1)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Release)
 
 # Prepare source files to be compiled
 aux_source_directory(./src SRC_ROOT)
@@ -29,22 +30,31 @@ set(MGXPARSER_SRCS ${DEFAULT_ANALYZER} ${DEFAULT_ANALYZER_BODY} ${SRC_ROOT} ${TO
 # WARNING: png depends on libz, so put it before z
 set(MGXPARSER_DEPENDENCIES ssl crypto png z)
 
+# Create an option for building static libraries
+OPTION(BUILD_STATIC "Build static libraries" ON)
+
 # Create static and shared libraries
 add_library("${PROJECT_NAME}_OBJECT" OBJECT ${MGXPARSER_SRCS})
 add_library("${PROJECT_NAME}_SHARED" SHARED $<TARGET_OBJECTS:${PROJECT_NAME}_OBJECT>)
-add_library("${PROJECT_NAME}_STATIC" STATIC $<TARGET_OBJECTS:${PROJECT_NAME}_OBJECT>)
 target_link_libraries("${PROJECT_NAME}_SHARED" ${MGXPARSER_DEPENDENCIES})
-target_link_libraries("${PROJECT_NAME}_STATIC" ${MGXPARSER_DEPENDENCIES})
+
+if(BUILD_STATIC)
+        add_library("${PROJECT_NAME}_STATIC" STATIC $<TARGET_OBJECTS:${PROJECT_NAME}_OBJECT>)
+        target_link_libraries("${PROJECT_NAME}_STATIC" ${MGXPARSER_DEPENDENCIES})
+endif()
 
 # Create static and shared executables
-add_executable("${PROJECT_NAME}_S_EXE" demo.cc)
-target_link_libraries("${PROJECT_NAME}_S_EXE" ${PROJECT_NAME}_STATIC)
-target_link_options("${PROJECT_NAME}_S_EXE" PRIVATE "-static")
+if(BUILD_STATIC)
+        add_executable("${PROJECT_NAME}_S_EXE" demo.cc)
+        target_link_libraries("${PROJECT_NAME}_S_EXE" ${PROJECT_NAME}_STATIC)
+        target_link_options("${PROJECT_NAME}_S_EXE" PRIVATE "-static")
+endif()
+
 add_executable("${PROJECT_NAME}_D_EXE" demo.cc)
 target_link_libraries("${PROJECT_NAME}_D_EXE" ${PROJECT_NAME}_SHARED)
 set_target_properties(${PROJECT_NAME}_D_EXE PROPERTIES
-    BUILD_WITH_INSTALL_RPATH TRUE
-    INSTALL_RPATH "$ORIGIN"
+        BUILD_WITH_INSTALL_RPATH TRUE
+        INSTALL_RPATH "$ORIGIN"
 )
 
 set(
@@ -59,14 +69,16 @@ set(
 )
 target_include_directories("${PROJECT_NAME}_OBJECT" PRIVATE ${MGXPARSER_INCLUDE})
 target_include_directories("${PROJECT_NAME}_D_EXE" PRIVATE ${MGXPARSER_INCLUDE})
-target_include_directories("${PROJECT_NAME}_S_EXE" PRIVATE ${MGXPARSER_INCLUDE})
+if(BUILD_STATIC)
+        target_include_directories("${PROJECT_NAME}_S_EXE" PRIVATE ${MGXPARSER_INCLUDE})
+endif()
 
 # Compile Node.js Addon
 add_definitions(-DNAPI_VERSION=3)
 # 检查napi.h是否存在于CMAKE_JS_INC目录中
 find_path(NAPI_H_FOUND "node_api.h" PATHS ${CMAKE_JS_INC})
 
-# 如果napi.h和CMAKE_JS_LIB都存在，创建mgxnodeS库
+# 如果napi.h和CMAKE_JS_LIB都存在，创建mgxnode库，node-addon必然是动态库
 if(NAPI_H_FOUND)
         # Include Node-API wrappers
         execute_process(COMMAND node -p "require('node-addon-api').include"
@@ -135,14 +147,14 @@ if (BUILD_TESTING)
             ${CMAKE_CURRENT_SOURCE_DIR}/test/test.cc
     )
     target_include_directories("${PROJECT_NAME}_TEST" PRIVATE ${MGXPARSER_INCLUDE})
-    target_link_libraries("${PROJECT_NAME}_TEST" ${PROJECT_NAME}_STATIC)
+    target_link_libraries("${PROJECT_NAME}_TEST" ${PROJECT_NAME}_SHARED)
     target_link_libraries("${PROJECT_NAME}_TEST" GTest::gtest_main)
     add_executable(
             "CURSOR_TEST"
             ${CMAKE_CURRENT_SOURCE_DIR}/test/cursor_test.cc
             src/tools/cursor.cc
     )
-    target_link_libraries("CURSOR_TEST" ${PROJECT_NAME}_STATIC)
+    target_link_libraries("CURSOR_TEST" ${PROJECT_NAME}_SHARED)
     target_link_libraries("CURSOR_TEST" GTest::gtest_main)
     include(GoogleTest)
     gtest_discover_tests("${PROJECT_NAME}_TEST")

Dockerfile

@@ -1,4 +1,8 @@
-# 使用多阶段构建，第一阶段用于编译
+# Usage: docker build -t mgxparser-alpine -f Dockerfile.alpine .
+#        url -X POST -F "file=@/root/projects/MgxParser/MgxParser/test/test_records/aitest.mgx2" -F "command={\"map\":\"HD\"}" http://localhost:4400
+
+# Phase 1: Compile the native module
+
 FROM node:20-slim as builder
 
 WORKDIR /app
@@ -12,12 +16,11 @@ RUN apt-get update && apt-get install -y \
 RUN npm install
 RUN npx cmake-js rebuild -p $(nproc)
 
-# 第二阶段用于运行
+# Phase 2: Deploy the native module and the app
 FROM node:20-slim
 
 WORKDIR /parser
 
-# 从构建阶段复制文件
 COPY --from=builder /app/build/Release/mgxnode.node .
 COPY --from=builder /app/docker_exe/app.js .
 COPY --from=builder /app/docker_exe/package.json .

Dockerfile.alpine

@@ -0,0 +1,31 @@
+# Usage: docker build -t mgxparser-alpine -f Dockerfile.alpine .
+#        curl -X POST -F "file=@/root/projects/MgxParser/MgxParser/test/test_records/aitest.mgx2" -F "command={\"map\":\"HD\"}" http://localhost:4400
+
+# Phase 1: Compile the native module
+FROM node:20.11.1-alpine3.19 as builder
+
+WORKDIR /app
+
+COPY . .
+
+RUN apk add --no-cache \
+    alpine-sdk \
+    cmake \
+    libpng-dev openssl-dev
+RUN npm install
+RUN npx cmake-js rebuild --CDBUILD_STATIC=OFF -p $(nproc)
+
+
+# Phase 2: Deploy the native module and the app
+FROM node:20.11.1-alpine3.19
+
+WORKDIR /parser
+
+COPY --from=builder /app/build/Release/mgxnode.node .
+COPY --from=builder /app/docker_exe/app.js .
+COPY --from=builder /app/docker_exe/package.json .
+
+RUN apk update && apk add libpng openssl
+RUN npm install
+
+CMD ["node", "app.js"]

README.md

@@ -1,5 +1,5 @@
 # **MgxParser**
-*This version(0.5.0) was compiled on 20240220*
+*This version(0.5.2) was compiled on 20240305*
 
 ## Introduction
 MgxParser is a C++ lib used to parse Age of Empires II game records.
@@ -74,6 +74,9 @@ Those keys are ensured to be in the output:
 - **realext**: File extension of the extracted file in .zip archive. e.g. .mgx, .aoe2record, etc.
 - **gameTime**: Time when this game played. Later DE versions have this recorded. Older versions use last modified time of the record file. If the input stream is not a file, will be current time.
 - **message**: A string contains some hints about the parsing process.
+- **matchup**: Matchup of this game. e.g. "1v1", "4v4", "1v2v3", etc. "N/A" if not available.
+- **version.code**: A string indicates the version of the record. e.g. "AOC10C", "DE", etc. "UNSUPPORTED" if not available.
+- **rawEncoding**: The encoding of the record file. e.g. "UTF-8", "ISO-8859-1", etc. "UNKNOWN" if not detected.
 
 ### About 'status'
 The 'status' value can be checked to determine whether the parsing was successful:   
@@ -121,7 +124,6 @@ get notified.
 These libraries are required to build MgxParser:
 - **CImg(bundled)**: Used to generate mini maps. This library is bundled into `libs/CImg`
   and compiled with MgxParser.
-- **movfuscator**: md5 function in this project was used to generate retroGuid
   of record. [Project page](https://github.com/xoreaxeaxeax/movfuscator/blob/ea37dae93fbcd93f642c71a53878da588bd7ddb4/validation/crypto-algorithms/md5_test.c)
 - **libpng**: Required by CImg. 
   ```sh
@@ -143,15 +145,14 @@ These libraries are required to build MgxParser:
 All dependencies of MgxParser are bundled into the executive file after compilation.
 
 ## How to compile
+A complie option `BUILD_STATIC` is provided to control whether to build a static library.
+Because some denpendencies don't provide a static version on alpine.
+
 To compile this project, latest version of CMake is recommended. See
 https://apt.kitware.com/ for details on this. I use CMake `3.24.1` and never
 tested other versions. On Ubuntu18 and newer versions, fresh version of cmake
 can be installed by:
 ```sh
-sudo snap install cmake --classic
-```
-or
-```sh
 sudo apt-get install cmake
 ```
 
@@ -181,6 +182,7 @@ The compiled node addon will be in `build/Release` directory.
 A demo of node addon is in `test/node_addon_test.js` directory.
 
 ## Version log
+- **0.5.2**: Modifications compiling on alpine. Add a static library option. Updated spdlog.
 - **0.5.0**: Refactored json output, make some keys mandatory. **Some key names changed!**
 - **0.4.6**: Replace md5 with openssl MD5 algorithm. Add ability to generate base64 encoded map data.
 - **0.4.5**: Reorganized source code. Refactored `parse()` function. Add node addon support. Add docker workflow.   

libs/spdlog/async.h

@@ -18,9 +18,9 @@
 #include <spdlog/details/registry.h>
 #include <spdlog/details/thread_pool.h>
 
+#include <functional>
 #include <memory>
 #include <mutex>
-#include <functional>
 
 namespace spdlog {
 
@@ -31,27 +31,25 @@ static const size_t default_async_q_size = 8192;
 // async logger factory - creates async loggers backed with thread pool.
 // if a global thread pool doesn't already exist, create it with default queue
 // size of 8192 items and single thread.
-template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-struct async_factory_impl
-{
-    template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args)
-    {
+template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl {
+    template <typename Sink, typename... SinkArgs>
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
         auto &registry_inst = details::registry::instance();
 
         // create global thread pool if not already exists..
 
         auto &mutex = registry_inst.tp_mutex();
         std::lock_guard<std::recursive_mutex> tp_lock(mutex);
         auto tp = registry_inst.get_tp();
-        if (tp == nullptr)
-        {
+        if (tp == nullptr) {
             tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
             registry_inst.set_tp(tp);
         }
 
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
+                                                         std::move(tp), OverflowPolicy);
         registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
@@ -60,40 +58,43 @@ struct async_factory_impl
 using async_factory = async_factory_impl<async_overflow_policy::block>;
 using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
 
-template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args)
-{
-    return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
+                                                    SinkArgs &&...sink_args) {
+    return async_factory::create<Sink>(std::move(logger_name),
+                                       std::forward<SinkArgs>(sink_args)...);
 }
 
-template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args)
-{
-    return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
+template <typename Sink, typename... SinkArgs>
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
+                                                       SinkArgs &&...sink_args) {
+    return async_factory_nonblock::create<Sink>(std::move(logger_name),
+                                                std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
-inline void init_thread_pool(
-    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
-{
-    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop);
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start,
+                             std::function<void()> on_thread_stop) {
+    auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
+                                                     on_thread_stop);
     details::registry::instance().set_tp(std::move(tp));
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
-{
+inline void init_thread_pool(size_t q_size,
+                             size_t thread_count,
+                             std::function<void()> on_thread_start) {
     init_thread_pool(q_size, thread_count, on_thread_start, [] {});
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count)
-{
+inline void init_thread_pool(size_t q_size, size_t thread_count) {
     init_thread_pool(
         q_size, thread_count, [] {}, [] {});
 }
 
 // get the global thread pool.
-inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
-{
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
     return details::registry::instance().get_tp();
 }
-} // namespace spdlog
+}  // namespace spdlog