feat(Core/Database): port TrinityCore database API

conf/dist/config.cmake

@@ -13,6 +13,7 @@ option(ENABLE_EXTRAS       "Set to 0 to disable extra features optimizing perfor
 option(ENABLE_VMAP_CHECKS  "Enable Checks relative to DisableMgr system on vmap"         1)
 option(ENABLE_EXTRA_LOGS   "Enable extra log functions that can be CPU intensive"        0)
 option(WITH_DYNAMIC_LINKING "Enable dynamic library linking."                            0)
+option(WITH_STRICT_DATABASE_TYPE_CHECKS "Enable strict checking of database field value accessors" 0)
 
 IsDynamicLinkingRequired(WITH_DYNAMIC_LINKING_FORCED)
 

src/cmake/showoptions.cmake

@@ -144,6 +144,15 @@ else()
   message("* Show source tree                : No (For UNIX default)")
 endif()
 
+if(WITH_STRICT_DATABASE_TYPE_CHECKS)
+  message("")
+  message(" *** WITH_STRICT_DATABASE_TYPE_CHECKS - WARNING!")
+  message(" *** Validates uses of database Get***() functions from Field class")
+  message(" *** invalid calls will result in returning value 0")
+  message(" *** NOT COMPATIBLE WITH MARIADB!")
+  add_definitions(-DACORE_STRICT_DATABASE_TYPE_CHECKS)
+endif()
+
 if(BUILD_SHARED_LIBS)
   message("")
   message(" *** WITH_DYNAMIC_LINKING - INFO!")

src/common/Threading/ProducerConsumerQueue.h

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
+ */
+
+#ifndef _PCQ_H
+#define _PCQ_H
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <atomic>
+#include <type_traits>
+
+template <typename T>
+class ProducerConsumerQueue
+{
+private:
+    std::mutex _queueLock;
+    std::queue<T> _queue;
+    std::condition_variable _condition;
+    std::atomic<bool> _shutdown;
+
+public:
+
+    ProducerConsumerQueue<T>() : _shutdown(false) { }
+
+    void Push(const T& value)
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+        _queue.push(std::move(value));
+
+        _condition.notify_one();
+    }
+
+    bool Empty()
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+
+        return _queue.empty();
+    }
+
+    bool Pop(T& value)
+    {
+        std::lock_guard<std::mutex> lock(_queueLock);
+
+        if (_queue.empty() || _shutdown)
+            return false;
+
+        value = _queue.front();
+
+        _queue.pop();
+
+        return true;
+    }
+
+    void WaitAndPop(T& value)
+    {
+        std::unique_lock<std::mutex> lock(_queueLock);
+
+        // we could be using .wait(lock, predicate) overload here but it is broken
+        // https://connect.microsoft.com/VisualStudio/feedback/details/1098841
+        while (_queue.empty() && !_shutdown)
+            _condition.wait(lock);
+
+        if (_queue.empty() || _shutdown)
+            return;
+
+        value = _queue.front();
+
+        _queue.pop();
+    }
+
+    void Cancel()
+    {
+        std::unique_lock<std::mutex> lock(_queueLock);
+
+        while (!_queue.empty())
+        {
+            T& value = _queue.front();
+
+            DeleteQueuedObject(value);
+
+            _queue.pop();
+        }
+
+        _shutdown = true;
+
+        _condition.notify_all();
+    }
+
+private:
+    template<typename E = T>
+    typename std::enable_if<std::is_pointer<E>::value>::type DeleteQueuedObject(E& obj) { delete obj; }
+
+    template<typename E = T>
+    typename std::enable_if<!std::is_pointer<E>::value>::type DeleteQueuedObject(E const& /*packet*/) { }
+};
+
+#endif

src/common/Utilities/AsyncCallbackProcessor.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
+ */
+
+#ifndef AsyncCallbackProcessor_h__
+#define AsyncCallbackProcessor_h__
+
+#include "Define.h"
+#include <algorithm>
+#include <vector>
+
+//template <class T>
+//concept AsyncCallback = requires(T t) { { t.InvokeIfReady() } -> std::convertible_to<bool> };
+
+template<typename T> // requires AsyncCallback<T>
+class AsyncCallbackProcessor
+{
+public:
+    AsyncCallbackProcessor() = default;
+    ~AsyncCallbackProcessor() = default;
+
+    T& AddCallback(T&& query)
+    {
+        _callbacks.emplace_back(std::move(query));
+        return _callbacks.back();
+    }
+
+    void ProcessReadyCallbacks()
+    {
+        if (_callbacks.empty())
+            return;
+
+        std::vector<T> updateCallbacks{ std::move(_callbacks) };
+
+        updateCallbacks.erase(std::remove_if(updateCallbacks.begin(), updateCallbacks.end(), [](T& callback)
+        {
+            return callback.InvokeIfReady();
+        }), updateCallbacks.end());
+
+        _callbacks.insert(_callbacks.end(), std::make_move_iterator(updateCallbacks.begin()), std::make_move_iterator(updateCallbacks.end()));
+    }
+
+private:
+    AsyncCallbackProcessor(AsyncCallbackProcessor const&) = delete;
+    AsyncCallbackProcessor& operator=(AsyncCallbackProcessor const&) = delete;
+
+    std::vector<T> _callbacks;
+};
+
+#endif // AsyncCallbackProcessor_h__

src/server/authserver/Main.cpp

@@ -24,6 +24,7 @@
 #include "RealmList.h"
 #include "RealmAcceptor.h"
 #include "DatabaseLoader.h"
+#include "MySQLThreading.h"
 #include "SecretMgr.h"
 #include "SharedDefines.h"
 #include "Util.h"
@@ -208,7 +209,7 @@ bool StartDB()
     // Load databases
     // NOTE: While authserver is singlethreaded you should keep synch_threads == 1.
     // Increasing it is just silly since only 1 will be used ever.
-    DatabaseLoader loader;
+    DatabaseLoader loader("server.authserver");
     loader
         .AddDatabase(LoginDatabase, "Login");
 

src/server/authserver/Server/AuthSocket.cpp

@@ -19,6 +19,7 @@
 #include "SecretMgr.h"
 #include "TOTP.h"
 #include "Threading.h"
+#include "Util.h"
 #include <algorithm>
 #include <openssl/crypto.h>
 #include <openssl/md5.h>
@@ -600,7 +601,7 @@ bool AuthSocket::_HandleLogonProof()
 
         // Update the sessionkey, last_ip, last login time and reset number of failed logins in the account table for this account
         // No SQL injection (escaped user name) and IP address as received by socket
-        PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGONPROOF);
+        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGONPROOF);
         stmt->setBinary(0, _sessionKey);
         stmt->setString(1, socket().getRemoteAddress().c_str());
         stmt->setUInt32(2, GetLocaleByName(_localizationName));
@@ -648,7 +649,7 @@ bool AuthSocket::_HandleLogonProof()
         // We can not include the failed account login hook. However, this is a workaround to still log this.
         if (sConfigMgr->GetOption<bool>("WrongPass.Logging", false))
         {
-            PreparedStatement* logstmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_FALP_IP_LOGGING);
+            LoginDatabasePreparedStatement* logstmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_FALP_IP_LOGGING);
             logstmt->setString(0, _accountInfo.Login);
             logstmt->setString(1, socket().getRemoteAddress());
             logstmt->setString(2, "Logged on failed AccountLogin due wrong password");
@@ -659,7 +660,7 @@ bool AuthSocket::_HandleLogonProof()
         if (MaxWrongPassCount > 0)
         {
             //Increment number of failed logins by one and if it reaches the limit temporarily ban that account or IP
-            PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_FAILEDLOGINS);
+            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_FAILEDLOGINS);
             stmt->setString(0, _accountInfo.Login);
             LoginDatabase.Execute(stmt);
 
@@ -747,7 +748,6 @@ bool AuthSocket::_HandleReconnectChallenge()
 
     auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_RECONNECTCHALLENGE);
     stmt->setString(0, login);
-
     PreparedQueryResult result = LoginDatabase.Query(stmt);
 
     // Stop if the account is not found
@@ -866,7 +866,7 @@ bool AuthSocket::_HandleRealmList()
 
     // Get the user id (else close the connection)
     // No SQL injection (prepared statement)
-    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_ID_BY_NAME);
+    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_ID_BY_NAME);
     stmt->setString(0, _accountInfo.Login);
 
     PreparedQueryResult result = LoginDatabase.Query(stmt);

src/server/database/CMakeLists.txt

@@ -6,6 +6,7 @@ CollectSourceFiles(
   ${CMAKE_CURRENT_SOURCE_DIR}
   PRIVATE_SOURCES
   # Exclude
+  ${CMAKE_CURRENT_SOURCE_DIR}/Updater
   ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders)
 
 if(USE_COREPCH)
@@ -40,12 +41,11 @@ target_include_directories(database
     ${CMAKE_CURRENT_BINARY_DIR})
 
 target_link_libraries(database
-  # PRIVATE
+  PRIVATE
     # acore-core-interface
-    # mysql
+    mysql
   PUBLIC
-    common
-    mysql)
+    common)
 
 set_target_properties(database
   PROPERTIES

src/server/database/Database/AdhocStatement.cpp

@@ -1,44 +1,45 @@
 /*
- * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
  */
 
 #include "AdhocStatement.h"
+#include "Errors.h"
 #include "MySQLConnection.h"
+#include "QueryResult.h"
+#include <cstdlib>
+#include <cstring>
 
 /*! Basic, ad-hoc queries. */
-BasicStatementTask::BasicStatementTask(const char* sql) :
-    m_has_result(false)
-{
-    m_sql = strdup(sql);
-}
-
-BasicStatementTask::BasicStatementTask(const char* sql, QueryResultFuture result) :
-    m_has_result(true),
-    m_result(result)
+BasicStatementTask::BasicStatementTask(char const* sql, bool async) :
+m_result(nullptr)
 {
     m_sql = strdup(sql);
+    m_has_result = async; // If the operation is async, then there's a result
+    if (async)
+        m_result = new QueryResultPromise();
 }
 
 BasicStatementTask::~BasicStatementTask()
 {
     free((void*)m_sql);
+    if (m_has_result && m_result != nullptr)
+        delete m_result;
 }
 
 bool BasicStatementTask::Execute()
 {
     if (m_has_result)
     {
         ResultSet* result = m_conn->Query(m_sql);
-        if (!result || !result->GetRowCount())
+        if (!result || !result->GetRowCount() || !result->NextRow())
         {
             delete result;
-            m_result.set(QueryResult(nullptr));
+            m_result->set_value(QueryResult(nullptr));
             return false;
         }
-        result->NextRow();
-        m_result.set(QueryResult(result));
+
+        m_result->set_value(QueryResult(result));
         return true;
     }
 

src/server/database/Database/AdhocStatement.h

@@ -1,30 +1,29 @@
 /*
- * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>
- * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
- * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ * Copyright (C) 2016+ AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license, you may redistribute it and/or modify it under version 2 of the License, or (at your option), any later version.
+ * Copyright (C) 2021+ WarheadCore <https://github.com/WarheadCore>
  */
 
 #ifndef _ADHOCSTATEMENT_H
 #define _ADHOCSTATEMENT_H
 
-#include <ace/Future.h>
+#include "DatabaseEnvFwd.h"
+#include "Define.h"
 #include "SQLOperation.h"
 
-typedef ACE_Future<QueryResult> QueryResultFuture;
 /*! Raw, ad-hoc query. */
-class BasicStatementTask : public SQLOperation
+class AC_DATABASE_API BasicStatementTask : public SQLOperation
 {
 public:
-    BasicStatementTask(const char* sql);
-    BasicStatementTask(const char* sql, QueryResultFuture result);
-    ~BasicStatementTask() override;
+    BasicStatementTask(char const* sql, bool async = false);
+    ~BasicStatementTask();
 
     bool Execute() override;
+    QueryResultFuture GetFuture() const { return m_result->get_future(); }
 
 private:
-    const char* m_sql;      //- Raw query to be executed
+    char const* m_sql;      //- Raw query to be executed
     bool m_has_result;
-    QueryResultFuture m_result;
+    QueryResultPromise* m_result;
 };
 
-#endif
+#endif