Refactor config, add settings command

.github/workflows/linux.yml

@@ -26,7 +26,7 @@ jobs:
           - distro: ubuntu
             version: 22.04
           - distro: ubuntu
-            version: 20.04
+            version: 24.04
     container:
       image: ${{ matrix.distro }}:${{ matrix.version }}
     steps:
@@ -97,7 +97,7 @@ jobs:
           - distro: ubuntu
             version: 22.04
           - distro: ubuntu
-            version: 20.04
+            version: 24.04
     container:
       image: ${{ matrix.distro }}:${{ matrix.version }}
     steps:

CMakeLists.txt

@@ -49,6 +49,7 @@ set(PRJ_HEADERS
     include/TServer.h
     include/VehicleData.h
     include/Env.h
+    include/Settings.h
     include/Profiling.h
     include/ChronoWrapper.h
 )
@@ -74,6 +75,7 @@ set(PRJ_SOURCES
     src/TServer.cpp
     src/VehicleData.cpp
     src/Env.cpp
+    src/Settings.cpp
     src/Profiling.cpp
     src/ChronoWrapper.cpp
 )

include/ChronoWrapper.h

@@ -4,5 +4,5 @@
 #include <string>
 
 namespace ChronoWrapper {
-    std::chrono::high_resolution_clock::duration TimeFromStringWithLiteral(const std::string& time_str);
+std::chrono::high_resolution_clock::duration TimeFromStringWithLiteral(const std::string& time_str);
 }

include/Common.h

@@ -37,6 +37,7 @@
 #include <filesystem>
 namespace fs = std::filesystem;
 
+#include "Settings.h"
 #include "TConsole.h"
 
 struct Version {
@@ -59,34 +60,6 @@ using SparseArray = std::unordered_map<size_t, T>;
 class Application final {
 public:
     // types
-    struct TSettings {
-        std::string ServerName { "BeamMP Server" };
-        std::string ServerDesc { "BeamMP Default Description" };
-        std::string ServerTags { "Freeroam" };
-        std::string Resource { "Resources" };
-        std::string MapName { "/levels/gridmap_v2/info.json" };
-        std::string Key {};
-        std::string Password {};
-        std::string SSLKeyPath { "./.ssl/HttpServer/key.pem" };
-        std::string SSLCertPath { "./.ssl/HttpServer/cert.pem" };
-        bool HTTPServerEnabled { false };
-        int MaxPlayers { 8 };
-        bool Private { true };
-        int MaxCars { 1 };
-        bool DebugModeEnabled { false };
-        int Port { 30814 };
-        std::string CustomIP {};
-        bool LogChat { true };
-        bool AllowGuests { true };
-        bool SendErrors { true };
-        bool SendErrorsMessageEnabled { true };
-        int HTTPServerPort { 8080 };
-        std::string HTTPServerIP { "127.0.0.1" };
-        bool HTTPServerUseSSL { false };
-        bool HideUpdateMessages { false };
-        std::string UpdateReminderTime { "30s" };
-        [[nodiscard]] bool HasCustomIP() const { return !CustomIP.empty(); }
-    };
 
     using TShutdownHandler = std::function<void()>;
 
@@ -104,7 +77,7 @@ class Application final {
     static std::string PPS() { return mPPS; }
     static void SetPPS(const std::string& NewPPS) { mPPS = NewPPS; }
 
-    static TSettings Settings;
+    static inline struct Settings Settings { };
 
     static std::vector<std::string> GetBackendUrlsInOrder() {
         return {
@@ -226,21 +199,21 @@ void RegisterThread(const std::string& str);
     #define luaprint(x) Application::Console().Write(_this_location + std::string("[LUA] ") + (x))
     #define beammp_debug(x)                                                                   \
         do {                                                                                  \
-            if (Application::Settings.DebugModeEnabled) {                                     \
+            if (Application::Settings.getAsBool(Settings::Key::General_Debug)) {                                     \
                 Application::Console().Write(_this_location + std::string("[DEBUG] ") + (x)); \
             }                                                                                 \
         } while (false)
     #define beammp_event(x)                                                                   \
         do {                                                                                  \
-            if (Application::Settings.DebugModeEnabled) {                                     \
+            if (Application::Settings.getAsBool(Settings::Key::General_Debug)) {                                     \
                 Application::Console().Write(_this_location + std::string("[EVENT] ") + (x)); \
             }                                                                                 \
         } while (false)
     // trace() is a debug-build debug()
     #if defined(DEBUG)
         #define beammp_trace(x)                                                                   \
             do {                                                                                  \
-                if (Application::Settings.DebugModeEnabled) {                                     \
+                if (Application::Settings.getAsBool(Settings::Key::General_Debug)) {                                     \
                     Application::Console().Write(_this_location + std::string("[TRACE] ") + (x)); \
                 }                                                                                 \
             } while (false)

include/CustomAssert.h

@@ -32,6 +32,7 @@
 #include <thread>
 
 #include "Common.h"
+#include "Compat.h"
 
 static const char* const ANSI_RESET = "\u001b[0m";
 
@@ -56,7 +57,7 @@ static const char* const ANSI_WHITE_BOLD = "\u001b[37;1m";
 static const char* const ANSI_BOLD = "\u001b[1m";
 static const char* const ANSI_UNDERLINE = "\u001b[4m";
 
-#ifdef DEBUG
+#if defined(DEBUG) && !defined(BEAMMP_FREEBSD)
 #include <iostream>
 inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const char* function, [[maybe_unused]] unsigned line,
     [[maybe_unused]] const char* condition_string, [[maybe_unused]] bool result) {
@@ -81,8 +82,8 @@ inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const ch
             beammp_errorf("Assertion failed in '{}:{}': {}.", __func__, _line, #cond); \
         }                                                                              \
     } while (false)
-#define beammp_assert_not_reachable()                                                      \
-    do {                                                                                   \
+#define beammp_assert_not_reachable()                                                                                                                           \
+    do {                                                                                                                                                        \
         beammp_errorf("Assertion failed in '{}:{}': Unreachable code reached. This may result in a crash or undefined state of the program.", __func__, _line); \
     } while (false)
 #endif // DEBUG

include/Json.h

@@ -17,7 +17,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 #pragma once
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/prettywriter.h"
 #include "rapidjson/document.h"
+#include "rapidjson/prettywriter.h"
+#include "rapidjson/stringbuffer.h"
 #include "rapidjson/writer.h"

include/RWMutex.h

@@ -23,8 +23,8 @@
  * and write locks and read locks are mutually exclusive.
  */
 
-#include <shared_mutex>
 #include <mutex>
+#include <shared_mutex>
 
 // Use ReadLock(m) and WriteLock(m) to lock it.
 using RWMutex = std::shared_mutex;

include/Settings.h

@@ -0,0 +1,144 @@
+// BeamMP, the BeamNG.drive multiplayer mod.
+// Copyright (C) 2024 BeamMP Ltd., BeamMP team and contributors.
+//
+// BeamMP Ltd. can be contacted by electronic mail via contact@beammp.com.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published
+// by the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+#include "Sync.h"
+#include <concepts>
+#include <cstdint>
+#include <doctest/doctest.h>
+#include <fmt/core.h>
+#include <fmt/format.h>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+struct ComposedKey {
+    std::string Category;
+    std::string Key;
+
+    bool operator==(const ComposedKey& rhs) const {
+        return (this->Category == rhs.Category && this->Key == rhs.Key);
+    }
+};
+
+template <>
+struct fmt::formatter<ComposedKey> : formatter<std::string> {
+    auto format(ComposedKey key, format_context& ctx) const;
+};
+
+inline auto fmt::formatter<ComposedKey>::format(ComposedKey key, fmt::format_context& ctx) const {
+    std::string key_metadata = fmt::format("{}::{}", key.Category, key.Key);
+    return formatter<std::string>::format(key_metadata, ctx);
+}
+
+namespace std {
+template <>
+class hash<ComposedKey> {
+public:
+    std::uint64_t operator()(const ComposedKey& key) const {
+        std::hash<std::string> hash_fn;
+        return hash_fn(key.Category + key.Key);
+    }
+};
+}
+
+struct Settings {
+    using SettingsTypeVariant = std::variant<std::string, bool, int>;
+
+    Settings();
+
+    enum Key {
+        // Keys that correspond to the keys set in TOML
+        // Keys have their TOML section name as prefix
+
+        // [Misc]
+        Misc_SendErrorsShowMessage,
+        Misc_SendErrors,
+        Misc_ImScaredOfUpdates,
+        Misc_UpdateReminderTime,
+
+        // [General]
+        General_Description,
+        General_Tags,
+        General_MaxPlayers,
+        General_Name,
+        General_Map,
+        General_AuthKey,
+        General_Private,
+        General_Port,
+        General_MaxCars,
+        General_LogChat,
+        General_ResourceFolder,
+        General_Debug,
+        General_AllowGuests
+    };
+
+    Sync<std::unordered_map<Key, SettingsTypeVariant>> SettingsMap;
+    enum SettingsAccessMask {
+        READ_ONLY, // Value can be read from console
+        READ_WRITE, // Value can be read and written to from console
+        NO_ACCESS // Value is inaccessible from console (no read OR write)
+    };
+
+    using SettingsAccessControl = std::pair<
+        Key, // The Key's corresponding enum encoding
+        SettingsAccessMask // Console read/write permissions
+        >;
+
+    Sync<std::unordered_map<ComposedKey, SettingsAccessControl>> InputAccessMapping;
+    std::string getAsString(Key key);
+
+    int getAsInt(Key key);
+
+    bool getAsBool(Key key);
+
+    SettingsTypeVariant get(Key key);
+
+    void set(Key key, const std::string& value);
+
+    template <typename Integer, std::enable_if_t<std::is_same_v<Integer, int>, bool> = true>
+    void set(Key key, Integer value) {
+        auto map = SettingsMap.synchronize();
+        if (!map->contains(key)) {
+            throw std::logic_error { "Undefined setting key accessed in Settings::set(int)" };
+        }
+        if (!std::holds_alternative<int>(map->at(key))) {
+            throw std::logic_error { fmt::format("Wrong value type in Settings::set(int): index {}", map->at(key).index()) };
+        }
+        map->at(key) = value;
+    }
+    template <typename Boolean, std::enable_if_t<std::is_same_v<bool, Boolean>, bool> = true>
+    void set(Key key, Boolean value) {
+        auto map = SettingsMap.synchronize();
+        if (!map->contains(key)) {
+            throw std::logic_error { "Undefined setting key accessed in Settings::set(bool)" };
+        }
+        if (!std::holds_alternative<bool>(map->at(key))) {
+            throw std::logic_error { fmt::format("Wrong value type in Settings::set(bool): index {}", map->at(key).index()) };
+        }
+        map->at(key) = value;
+    }
+
+    const std::unordered_map<ComposedKey, SettingsAccessControl> getAccessControlMap() const;
+    SettingsAccessControl getConsoleInputAccessMapping(const ComposedKey& keyName);
+
+    void setConsoleInputAccessMapping(const ComposedKey& keyName, const std::string& value);
+    void setConsoleInputAccessMapping(const ComposedKey& keyName, int value);
+    void setConsoleInputAccessMapping(const ComposedKey& keyName, bool value);
+};

include/Sync.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <boost/thread/synchronized_value.hpp>
+#include <mutex>
+
+/// This header provides convenience aliases for synchronization primitives.
+
+template <typename T>
+using Sync = boost::synchronized_value<T, std::recursive_mutex>;

include/TConfig.h

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "Common.h"
+#include "Settings.h"
 
 #include <atomic>
 #include <filesystem>
@@ -40,9 +41,7 @@ class TConfig {
 private:
     void CreateConfigFile();
     void ParseFromFile(std::string_view name);
-    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, std::string& OutValue);
-    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, bool& OutValue);
-    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, int& OutValue);
+    void TryReadValue(toml::value& Table, const std::string& Category, const std::string_view& Key, const std::string_view& Env, Settings::Key key);
 
     void ParseOldFormat();
     std::string TagsAsPrettyArray() const;

include/TPPSMonitor.h

@@ -27,7 +27,7 @@ class TNetwork;
 class TPPSMonitor : public IThreaded {
 public:
     explicit TPPSMonitor(TServer& Server);
-    virtual ~TPPSMonitor() {}
+    virtual ~TPPSMonitor() { }
 
     void operator()() override;
 

src/ChronoWrapper.cpp

@@ -2,25 +2,21 @@
 #include "Common.h"
 #include <regex>
 
-std::chrono::high_resolution_clock::duration ChronoWrapper::TimeFromStringWithLiteral(const std::string& time_str)
-{
+std::chrono::high_resolution_clock::duration ChronoWrapper::TimeFromStringWithLiteral(const std::string& time_str) {
     // const std::regex time_regex(R"((\d+\.{0,1}\d*)(min|ms|us|ns|[dhs]))"); //i.e one of: "25ns, 6us, 256ms, 2s, 13min, 69h, 356d" will get matched (only available in newer C++ versions)
-    const std::regex time_regex(R"((\d+\.{0,1}\d*)(min|[dhs]))"); //i.e one of: "2.01s, 13min, 69h, 356.69d" will get matched
+    const std::regex time_regex(R"((\d+\.{0,1}\d*)(min|[dhs]))"); // i.e one of: "2.01s, 13min, 69h, 356.69d" will get matched
     std::smatch match;
     float time_value;
-    if (!std::regex_search(time_str, match, time_regex)) return std::chrono::nanoseconds(0);
+    if (!std::regex_search(time_str, match, time_regex))
+        return std::chrono::nanoseconds(0);
     time_value = stof(match.str(1));
-    beammp_debugf("Parsed time was: {}{}", time_value, match.str(2));
     if (match.str(2) == "d") {
-        return std::chrono::seconds((uint64_t)(time_value * 86400)); //86400 seconds in a day
-    }
-    else if (match.str(2) == "h") {
-        return std::chrono::seconds((uint64_t)(time_value * 3600)); //3600 seconds in an hour
-    }
-    else if (match.str(2) == "min") {
+        return std::chrono::seconds((uint64_t)(time_value * 86400)); // 86400 seconds in a day
+    } else if (match.str(2) == "h") {
+        return std::chrono::seconds((uint64_t)(time_value * 3600)); // 3600 seconds in an hour
+    } else if (match.str(2) == "min") {
         return std::chrono::seconds((uint64_t)(time_value * 60));
-    }
-    else if (match.str(2) == "s") {
+    } else if (match.str(2) == "s") {
         return std::chrono::seconds((uint64_t)time_value);
     }
     return std::chrono::nanoseconds(0);