Add config

Rename commands

Author: dedmen

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "wolfssl"]
 	path = wolfssl
 	url = https://github.com/wolfSSL/wolfssl
+[submodule "yaml-cpp"]
+	path = yaml-cpp
+	url = https://github.com/jbeder/yaml-cpp.git

CMakeLists.txt

@@ -29,6 +29,16 @@ else()
     set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/build/win32/")
 endif()
 
+
+#yaml resets c++17 so I just move it above ours so we don't have to re-set
+SET(YAML_CPP_BUILD_TESTS OFF CACHE BOOL "Don't want" FORCE)
+SET(YAML_CPP_BUILD_TOOLS OFF CACHE BOOL "Don't want" FORCE)
+SET(YAML_CPP_BUILD_TESTS OFF CACHE BOOL "Don't want" FORCE)
+SET(YAML_CPP_INSTALL OFF CACHE BOOL "Don't want" FORCE)
+SET(MSVC_SHARED_RT OFF CACHE BOOL "want static" FORCE)
+
+add_subdirectory(yaml-cpp)
+
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -53,7 +63,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
 else()
 	set(CMAKE_CXX_FLAGS_DEBUG "/D_DEBUG /MTd /Zi /Ob0 /Od /RTC1 /MP /EHsc")
 	set(CMAKE_CXX_FLAGS_RELEASE "/MT /Zi /O2 /Ob1 /EHsc /MP") #with debug info
-    set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG /MTd /Zi /Ob0 /Od /RTC1 /MP /EHsc")
+	set(CMAKE_C_FLAGS_DEBUG "/D_DEBUG /MTd /Zi /Ob0 /Od /RTC1 /MP /EHsc")
 	set(CMAKE_C_FLAGS_RELEASE "/MT /Zi /O2 /Ob1 /EHsc /MP") #with debug info
 	set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "/OPT:REF /DEBUG:FULL") 
 endif()
@@ -70,5 +80,11 @@ add_subdirectory(mariadbpp)
 
 include_directories(AFTER "${PROJECT_SOURCE_DIR}/mariadbpp/include")
 include_directories(AFTER "${PROJECT_SOURCE_DIR}/mariadb-connector-c/include")
+
+
+
+
+
+
 add_subdirectory(src)
 

CMakeSettings.json

@@ -12,6 +12,19 @@
       "cmakeCommandArgs": "",
       "buildCommandArgs": "",
       "ctestCommandArgs": ""
+    },
+    {
+      "name": "x64-Release",
+      "generator": "Visual Studio 15 2017 Win64",
+      "configurationType": "Release",
+      "inheritEnvironments": [
+        "msvc_x64_x64"
+      ],
+      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
+      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": ""
     }
   ]
 }

src/CMakeLists.txt

@@ -38,7 +38,7 @@ file(GLOB INTERCEPT_HOST_SOURCES "${INTERCEPT_CLIENT_PATH}/intercept/client/*.cp
 SOURCE_GROUP("intercept" FILES ${INTERCEPT_HOST_SOURCES})
 
 add_library(${INTERCEPT_PLUGIN_NAME} SHARED ${INTERCEPT_PLUGIN_SOURCES} ${INTERCEPT_HOST_SOURCES})
-target_link_libraries(${INTERCEPT_PLUGIN_NAME} mariadbclientpp)
+target_link_libraries(${INTERCEPT_PLUGIN_NAME} mariadbclientpp yaml-cpp)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${INTERCEPT_INCLUDE_PATH})
 

src/config.cpp

@@ -0,0 +1,92 @@
+#include "config.h"
+#include <filesystem>
+#include "yaml-cpp/yaml.h"
+
+
+namespace YAML {
+    template<>
+    struct convert<r_string> {
+        static Node encode(const r_string& rhs) {
+            Node node;
+            node = static_cast<std::string>(rhs);
+            return node;
+        }
+
+        static bool decode(const Node& node, r_string& rhs) {
+            if (!node.IsScalar()) {
+                return false;
+            }
+
+            rhs = node.as<std::string>();
+            return true;
+        }
+    };
+}
+
+
+
+void Config::reloadConfig() {
+    std::filesystem::path configFilePath("@InterceptDB/config.yaml");
+
+    if (!std::filesystem::exists(configFilePath))
+        throw std::filesystem::filesystem_error("File not found", configFilePath, std::error_code());
+
+    auto stringpath = configFilePath.string();
+    YAML::Node config = YAML::LoadFile(configFilePath.string());
+
+    if (!config["accounts"].IsMap()) throw std::runtime_error("Config Accounts entry is not a map");
+
+    for (auto& it : config["accounts"]) {
+        r_string accountName = it.first.as<r_string>();
+        auto value = it.second;
+
+        if (!value["ip"]) throw std::runtime_error("Undefined account value: ip");
+        if (!value["username"]) throw std::runtime_error("Undefined account value: username");
+        if (!value["password"]) throw std::runtime_error("Undefined account value: password");
+        if (!value["database"]) throw std::runtime_error("Undefined account value: database");
+
+        auto ip = value["ip"].as<r_string>();
+        auto user = value["username"].as<r_string>();
+        auto password = value["password"].as<r_string>();
+        auto database = value["database"].as<r_string>();
+        auto port = value["port"].as<int>(3306);
+
+        auto acc = mariadb::account::create(ip, user, password, database, port);
+
+        accounts[accountName] = acc;
+    }
+
+    for (auto& it : config["statements"]) {
+        r_string stmtName = it.first.as<r_string>();
+        statements[stmtName] = it.second.as<r_string>();        
+    }
+
+
+}
+
+
+game_value cmd_reloadConfig(uintptr_t) {
+
+
+
+    try {
+        Config::get().reloadConfig();
+    }
+    catch (YAML::BadConversion& x) {
+        return "error " + x.msg + " in L" + std::to_string(x.mark.line);
+    }
+    catch (std::runtime_error& x) {
+        return r_string("error ") + x.what();
+    }
+    catch (YAML::ParserException& x) {
+      return "error " + x.msg + " in L" + std::to_string(x.mark.line);
+    }
+    return {};
+}
+
+void Config::initCommands() {
+    
+    handle_cmd_reloadConfig = intercept::client::host::register_sqf_command("dbReloadConfig", "TODO", cmd_reloadConfig, game_data_type::STRING);
+
+
+}

src/config.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <intercept.hpp>
+#include "../intercept/src/host/common/singleton.hpp"
+#include <vector>
+#include "mariadb++/account.hpp"
+#include "../intercept/src/client/headers/shared/containers.hpp"
+
+class Config : public intercept::singleton<Config> {
+    
+public:
+    void reloadConfig();
+
+    r_string getQuery(r_string name) {
+        auto found = statements.find(name);
+        if (found == statements.end()) return r_string();
+        return found->second;
+    }
+
+    mariadb::account_ref getAccount(r_string name) {
+        auto found = accounts.find(name);
+        if (found == accounts.end()) return {};
+        return found->second;
+    }
+
+    static void initCommands();
+    static inline registered_sqf_function handle_cmd_reloadConfig;
+
+private:
+    std::map<intercept::types::r_string, mariadb::account_ref> accounts;
+    std::map<intercept::types::r_string, intercept::types::r_string> statements;
+
+
+
+};

src/connection.cpp

@@ -2,6 +2,8 @@
 #include <mariadb++/connection.hpp>
 #include "query.h"
 #include "res.h"
+#include "mariadb++/exceptions.hpp"
+#include <winsock2.h>
 
 using namespace intercept::client;
 extern auto_array<ref<GameDataDBAsyncResult>> asyncWork;
@@ -72,6 +74,18 @@ game_value Connection::cmd_createConnectionArray(uintptr_t, game_value_parameter
 
     newCon->session = mariadb::connection::create(acc);
 
+    return newCon;
+}
+
+game_value Connection::cmd_createConnectionConfig(uintptr_t, game_value_parameter right) {
+    
+    auto acc = Config::get().getAccount(right);
+    if (!acc) return  {};
+
+
+    auto newCon = new GameDataDBConnection();
+
+    newCon->session = mariadb::connection::create(acc);
 
     return newCon;
 }
@@ -119,7 +133,7 @@ class callstack_item_WaitForQueryResult : public vm_context::callstack_item {
 
 };
 
-game_value Connection::cmd_query(uintptr_t g , game_value_parameter con, game_value_parameter qu) {
+game_value Connection::cmd_execute(uintptr_t g , game_value_parameter con, game_value_parameter qu) {
 
     auto gs = reinterpret_cast<game_state*>(g);
 
@@ -129,7 +143,7 @@ game_value Connection::cmd_query(uintptr_t g , game_value_parameter con, game_va
     auto session = con.get_as<GameDataDBConnection>()->session;
     auto query = qu.get_as<GameDataDBQuery>();
 
-    auto statement = session->create_statement(query->queryString);
+    auto statement = session->create_statement(query->getQueryString());
 
     uint32_t idx = 0;
     for (auto& it : query->boundValues) {
@@ -172,28 +186,38 @@ game_value Connection::cmd_query(uintptr_t g , game_value_parameter con, game_va
     return 123;
 }
 
-game_value Connection::cmd_queryAsync(uintptr_t, game_value_parameter con, game_value_parameter qu) {
+game_value Connection::cmd_executeAsync(uintptr_t, game_value_parameter con, game_value_parameter qu) {
 
     auto session = con.get_as<GameDataDBConnection>()->session;
     auto query = qu.get_as<GameDataDBQuery>();
 
     auto gd_res = new GameDataDBAsyncResult();
     gd_res->data = std::make_shared<GameDataDBAsyncResult::dataT>();
     gd_res->data->res = 
-    std::async(std::launch::async,[session, stmt = query->queryString, boundV = query->boundValues]() -> mariadb::result_set_ref
+    std::async(std::launch::async,[session, stmt = query->getQueryString(), boundV = query->boundValues]() -> mariadb::result_set_ref
     {
-        auto statement = session->create_statement(stmt);
 
-        uint32_t idx = 0;
-        for (auto& it : boundV) {
+        try {
+            auto statement = session->create_statement(stmt);
+            uint32_t idx = 0;
+            for (auto& it : boundV) {
 
-            switch (it.type_enum()) {
+                switch (it.type_enum()) {
                 case game_data_type::SCALAR: statement->set_float(idx++, static_cast<float>(it)); break;
                 case game_data_type::BOOL: statement->set_boolean(idx++, static_cast<bool>(it)); break;
                 case game_data_type::STRING: statement->set_string(idx++, static_cast<r_string>(it)); break;
+                }
             }
+            return statement->query();
+        } catch (mariadb::exception::connection& x) {
+            __debugbreak();
+
+
+            return {};
         }
-        return statement->query();
+        
+
+
     });
     asyncWork.emplace_back(gd_res);
     return gd_res;
@@ -206,7 +230,8 @@ void Connection::initCommands() {
     GameDataDBConnection_type = dbType.second;
 
 
-    handle_cmd_createConnection = host::register_sqf_command("db_createConnection", "TODO", Connection::cmd_createConnectionArray, GameDataDBConnection_typeE, game_data_type::ARRAY);
-    handle_cmd_query = host::register_sqf_command("db_query", "TODO", Connection::cmd_query, Result::GameDataDBResult_typeE, GameDataDBConnection_typeE, Query::GameDataDBQuery_typeE);
-    handle_cmd_queryAsync = host::register_sqf_command("db_queryAsync", "TODO", Connection::cmd_queryAsync, Result::GameDataDBAsyncResult_typeE, GameDataDBConnection_typeE, Query::GameDataDBQuery_typeE);
+    handle_cmd_createConnection = host::register_sqf_command("dbCreateConnection", "TODO", Connection::cmd_createConnectionArray, GameDataDBConnection_typeE, game_data_type::ARRAY);
+    handle_cmd_createConnectionConfig = host::register_sqf_command("dbCreateConnection", "TODO", Connection::cmd_createConnectionConfig, GameDataDBConnection_typeE, game_data_type::STRING);
+    handle_cmd_execute = host::register_sqf_command("dbExecute", "TODO", Connection::cmd_execute, Result::GameDataDBResult_typeE, GameDataDBConnection_typeE, Query::GameDataDBQuery_typeE);
+    handle_cmd_executeAsync = host::register_sqf_command("dbExecuteAsync", "TODO", Connection::cmd_executeAsync, Result::GameDataDBAsyncResult_typeE, GameDataDBConnection_typeE, Query::GameDataDBQuery_typeE);
 }

src/connection.h

@@ -8,9 +8,10 @@ using namespace intercept::types;
 class Connection {
 public:
 
-	static game_value cmd_createConnectionArray(uintptr_t, game_value_parameter right);
-    static game_value cmd_query(uintptr_t, game_value_parameter con, game_value_parameter qu);
-    static game_value cmd_queryAsync(uintptr_t, game_value_parameter con, game_value_parameter qu);
+    static game_value cmd_createConnectionArray(uintptr_t, game_value_parameter right);
+    static game_value cmd_createConnectionConfig(uintptr_t, game_value_parameter right);
+    static game_value cmd_execute(uintptr_t, game_value_parameter con, game_value_parameter qu);
+    static game_value cmd_executeAsync(uintptr_t, game_value_parameter con, game_value_parameter qu);
 
 
 
@@ -20,7 +21,8 @@ class Connection {
 	static inline game_data_type GameDataDBConnection_typeE;
 
 
-	static inline types::registered_sqf_function handle_cmd_createConnection;
-    static inline types::registered_sqf_function handle_cmd_query;
-    static inline types::registered_sqf_function handle_cmd_queryAsync;
+    static inline types::registered_sqf_function handle_cmd_createConnection;
+    static inline types::registered_sqf_function handle_cmd_createConnectionConfig;
+    static inline types::registered_sqf_function handle_cmd_execute;
+    static inline types::registered_sqf_function handle_cmd_executeAsync;
 };

src/main.cpp

@@ -3,6 +3,7 @@
 #include "res.h"
 #include "query.h"
 #include "connection.h"
+#include "yaml-cpp/exceptions.h"
 
 int intercept::api_version() { //This is required for the plugin to work.
     return 1;
@@ -16,18 +17,25 @@ void intercept::pre_start() {
     Result::initCommands();
     Query::initCommands();
     Connection::initCommands();
+    Config::initCommands();
 }
 
 void intercept::pre_init() {
-
-    //mysqlx::Session sess("localhost", 3306, "intercepttest", "password");
-    //
-    //auto db = sess.sql("USE ?").bind("databasename").execute();
-    //
-    //
-    //auto query = sess.sql("SELECT * FROM ?").bind("testdata");
-    //query.execute();
-
+    try {
+        Config::get().reloadConfig();
+    }
+    catch (YAML::BadConversion& x) {
+        sqf::diag_log ("Database config error " + x.msg + " in L" + std::to_string(x.mark.line));
+        sqf::system_chat("Database config error " + x.msg + " in L" + std::to_string(x.mark.line));
+    }
+    catch (std::runtime_error& x) {
+        sqf::diag_log(r_string("Database config error ") + x.what());
+        sqf::system_chat(r_string("Database config error ") + x.what());
+    }
+    catch (YAML::ParserException& x) {
+        sqf::diag_log("Database config error " + x.msg + " in L" + std::to_string(x.mark.line));
+        sqf::system_chat("Database config error " + x.msg + " in L" + std::to_string(x.mark.line));
+    }
 
     intercept::sqf::system_chat("Intercept database has been loaded");
 }