Merge remote-tracking branch 'origin/new-lua-features' into rewrite-lua

This is the first of a few commits to merge the new lua features and the
rewrite

include/Client.h

@@ -13,6 +13,11 @@
 
 class TServer;
 
+#ifdef WIN32
+// for socklen_t
+#include <WS2tcpip.h>
+#endif // WIN32
+
 struct TConnection final {
     SOCKET Socket;
     struct sockaddr SockAddr;

include/Common.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#include "TSentry.h"
+extern TSentry Sentry;
+
+#include <array>
 #include <atomic>
 #include <cstring>
 #include <deque>
@@ -17,6 +21,7 @@ struct Version {
     uint8_t minor;
     uint8_t patch;
     Version(uint8_t major, uint8_t minor, uint8_t patch);
+    Version(const std::array<uint8_t, 3>& v);
     std::string AsString();
 };
 
@@ -67,13 +72,18 @@ public:
     static const Version& ServerVersion() { return mVersion; }
     static std::string ClientVersionString() { return "2.0"; }
     static std::string PPS() { return mPPS; }
-    static void SetPPS(std::string NewPPS) { mPPS = NewPPS; }
+    static void SetPPS(const std::string& NewPPS) { mPPS = NewPPS; }
 
     static inline TSettings Settings {};
 
     static std::string GetBackendUrlForAuth() { return "auth.beammp.com"; }
     static std::string GetBackendHostname() { return "backend.beammp.com"; }
+    static std::string GetBackup1Hostname() { return "backup1.beammp.com"; }
+    static std::string GetBackup2Hostname() { return "backup2.beammp.com"; }
     static std::string GetBackendUrlForSocketIO() { return "https://backend.beammp.com"; }
+    static void CheckForUpdates();
+    static std::array<uint8_t, 3> VersionStrToInts(const std::string& str);
+    static bool IsOutdated(const Version& Current, const Version& Newest);
 
 private:
     static inline std::string mPPS;
@@ -81,11 +91,11 @@ private:
     static inline std::mutex mShutdownHandlersMutex {};
     static inline std::deque<TShutdownHandler> mShutdownHandlers {};
 
-    static inline Version mVersion { 2, 3, 0 };
+    static inline Version mVersion { 2, 4, 0 };
 };
 
-std::string ThreadName();
-void RegisterThread(const std::string str);
+std::string ThreadName(bool DebugModeOverride = false);
+void RegisterThread(const std::string& str);
 #define RegisterThreadAuto() RegisterThread(__func__)
 
 #define KB 1024
@@ -124,8 +134,11 @@ void RegisterThread(const std::string str);
 
 #define beammp_warn(x) Application::Console().Write(_this_location + std::string("[WARN] ") + (x))
 #define beammp_info(x) Application::Console().Write(_this_location + std::string("[INFO] ") + (x))
-#define beammp_error(x) Application::Console().Write(_this_location + std::string("[ERROR] ") + (x))
-#define beammp_lua_error(x) Application::Console().Write(_this_location + std::string("[LUA ERROR] ") + (x))
+#define error(x)                                                                      \
+    do {                                                                              \
+        Application::Console().Write(_this_location + std::string("[ERROR] ") + (x)); \
+        Sentry.AddErrorBreadcrumb((x), _file_basename, _line);                        \
+    } while (false)
 #define luaprint(x) Application::Console().Write(_this_location + std::string("[LUA] ") + (x))
 #define beammp_debug(x)                                                                   \
     do {                                                                                  \
@@ -136,6 +149,19 @@ void RegisterThread(const std::string str);
 // for those times when you just need to ignore something :^)
 // explicity disables a [[nodiscard]] warning
 #define beammp_ignore(x) (void)x
+// trace() is a debug-build debug()
+#if defined(DEBUG)
+#define trace(x)                                                                          \
+    do {                                                                                  \
+        if (Application::Settings.DebugModeEnabled) {                                     \
+            Application::Console().Write(_this_location + std::string("[TRACE] ") + (x)); \
+        }                                                                                 \
+    } while (false)
+#else
+#define trace(x)
+#endif // defined(DEBUG)
+
+void LogChatMessage(const std::string& name, int id, const std::string& msg);
 
 #define Biggest 30000
 std::string Comp(std::string Data);

include/Compat.h

@@ -13,9 +13,9 @@ using DWORD = unsigned long;
 using PDWORD = unsigned long*;
 using LPDWORD = unsigned long*;
 char _getch();
-inline void CloseSocketProper(int socket) {
-    shutdown(socket, SHUT_RDWR);
-    close(socket);
+inline void CloseSocketProper(int TheSocket) {
+    shutdown(TheSocket, SHUT_RDWR);
+    close(TheSocket);
 }
 #endif // unix
 
@@ -24,10 +24,10 @@ inline void CloseSocketProper(int socket) {
 #ifdef WIN32
 #include <conio.h>
 #include <winsock2.h>
-#include <ws2tcpip.h>
-inline void CloseSocketProper(SOCKET socket) {
-    shutdown(socket, SD_BOTH);
-    closesocket(socket);
+inline void CloseSocketProper(SOCKET TheSocket) {
+    shutdown(TheSocket, 2); // 2 == SD_BOTH
+    closesocket(TheSocket);
+
 }
 #endif // WIN32
 
@@ -35,4 +35,4 @@ inline void CloseSocketProper(SOCKET socket) {
 
 #if !defined(WIN32) && !defined(__unix)
 #error "OS not supported"
-#endif
+#endif

include/CustomAssert.h

@@ -40,7 +40,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";
 
-#if DEBUG
+#ifdef DEBUG
 #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) {
@@ -60,9 +60,14 @@ inline void _assert([[maybe_unused]] const char* file, [[maybe_unused]] const ch
 #else
 // In release build, these macros turn into NOPs. The compiler will optimize these out.
 #define beammp_assert(x) \
-    do {          \
+    do {                                                              \
+        bool result = (cond);                                         \
+        if (!result) {                                                \
+            Sentry.LogAssert(#cond, _file_basename, _line, __func__); \
+        }                                                             \
     } while (false)
 #define beammp_assert_not_reachable() \
-    do {                     \
+    do {                                                                          \
+        Sentry.LogAssert("code is unreachable", _file_basename, _line, __func__); \
     } while (false)
 #endif // DEBUG

include/Defer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <functional>
+
+template <typename FnT>
+class Defer final {
+public:
+    Defer(FnT fn)
+        : mFunction([&fn] { (void)fn(); }) { }
+    ~Defer() {
+        if (mFunction) {
+            mFunction();
+        }
+    }
+
+private:
+    std::function<void()> mFunction;
+};

include/Http.h

@@ -6,5 +6,8 @@
 namespace Http {
 std::string GET(const std::string& host, int port, const std::string& target, unsigned int* status = nullptr);
 std::string POST(const std::string& host, int port, const std::string& target, const std::unordered_map<std::string, std::string>& fields, const std::string& body, const std::string& ContentType, unsigned int* status = nullptr);
-static inline const char* ErrorString = "!BeamMPHttpsError!";
+namespace Status {
+    std::string ToString(int code);
+}
+const std::string ErrorString = "-1";
 }

include/SocketIO.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <deque>
-#include <mutex>
-#include <sio_client.h>
-#include <thread>
-#include <memory>
-
-/*
- * We send relevant server events over socket.io to the backend.
- *
- * We send all events to `backend.beammp.com`, to the room `/key` 
- * where `key` is the currently active auth-key. 
- */
-
-enum class SocketIOEvent {
-    ConsoleOut,
-    CPUUsage,
-    MemoryUsage,
-    NetworkUsage,
-    PlayerList,
-};
-
-enum class SocketIORoom {
-    None,
-    Stats,
-    Player,
-    Info,
-    Console,
-};
-
-class SocketIO final {
-private:
-    struct Event;
-
-public:
-    enum class EventType {
-    };
-
-    // Singleton pattern
-    static SocketIO& Get();
-
-    void Emit(SocketIOEvent Event, const std::string& Data);
-
-    ~SocketIO();
-
-    void SetAuthenticated(bool auth) { mAuthenticated = auth; }
-
-private:
-    SocketIO() noexcept;
-
-    void ThreadMain();
-
-    struct Event {
-        std::string Name;
-        std::string Data;
-    };
-
-    bool mAuthenticated { false };
-    sio::client mClient;
-    std::thread mThread;
-    std::atomic_bool mCloseThread { false };
-    std::mutex mQueueMutex;
-    std::deque<Event> mQueue;
-
-    friend std::unique_ptr<SocketIO> std::make_unique<SocketIO>();
-};
-

include/TSentry.h

@@ -0,0 +1,38 @@
+#ifndef SENTRY_H
+#define SENTRY_H
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+enum class SentryLevel {
+    Debug = -1,
+    Info = 0,
+    Warning = 1,
+    Error = 2,
+    Fatal = 3,
+};
+
+// singleton, dont make this twice
+class TSentry final {
+public:
+    TSentry();
+    ~TSentry();
+
+    void PrintWelcome();
+    void SetupUser();
+    void Log(SentryLevel level, const std::string& logger, const std::string& text);
+    void LogError(const std::string& text, const std::string& file, const std::string& line);
+    void SetContext(const std::string& context_name, const std::unordered_map<std::string, std::string>& map);
+    void LogException(const std::exception& e, const std::string& file, const std::string& line);
+    void LogAssert(const std::string& condition_string, const std::string& file, const std::string& line, const std::string& function);
+    void AddErrorBreadcrumb(const std::string& msg, const std::string& file, const std::string& line);
+    // cleared when Logged
+    void SetTransaction(const std::string& id);
+    [[nodiscard]] std::unique_lock<std::mutex> CreateExclusiveContext();
+
+private:
+    bool mValid { true };
+    std::mutex mMutex;
+};
+
+#endif // SENTRY_H