DatabaseLoader Class Reference

#include "DatabaseLoader.h"

Public Types
enum	DatabaseTypeFlags {   DATABASE_NONE = 0 ,   DATABASE_LOGIN = 1 ,   DATABASE_CHARACTER = 2 ,   DATABASE_WORLD = 4 ,   DATABASE_DBC = 8 ,   DATABASE_MODULE = 16 ,   DATABASE_MASK_ALL = DATABASE_LOGIN | DATABASE_CHARACTER | DATABASE_WORLD | DATABASE_DBC | DATABASE_MODULE }

Public Member Functions
	DatabaseLoader (std::string const &logger, uint32 const defaultUpdateMask=0, std::string_view modulesList={})
template<class T >
DatabaseLoader &	AddDatabase (DatabaseWorkerPool< T > &pool, std::string const &name)
bool	Load ()
uint32	GetUpdateFlags () const

Private Types
using	Predicate = std::function< bool()>
using	Closer = std::function< void()>

Private Member Functions
bool	OpenDatabases ()
bool	PopulateDatabases ()
bool	UpdateDatabases ()
bool	PrepareStatements ()
bool	Process (std::queue< Predicate > &queue)

Private Attributes
std::string const	_logger
std::string_view	_modulesList
bool const	_autoSetup
uint32 const	_updateFlags
std::queue< Predicate >	_open
std::queue< Predicate >	_populate
std::queue< Predicate >	_update
std::queue< Predicate >	_prepare
std::stack< Closer >	_close

Detailed Description

Member Typedef Documentation

Closer

using DatabaseLoader::Closer = std::function<void()>

private

Predicate

using DatabaseLoader::Predicate = std::function<bool()>

private

Member Enumeration Documentation

DatabaseTypeFlags

enum DatabaseLoader::DatabaseTypeFlags

Enumerator
DATABASE_NONE
DATABASE_LOGIN
DATABASE_CHARACTER
DATABASE_WORLD
DATABASE_DBC
DATABASE_MODULE
DATABASE_MASK_ALL

    {
        DATABASE_NONE       = 0,
 
        DATABASE_LOGIN      = 1,
        DATABASE_CHARACTER  = 2,
        DATABASE_WORLD      = 4,
        DATABASE_DBC        = 8,
        DATABASE_MODULE     = 16,
 
        DATABASE_MASK_ALL   = DATABASE_LOGIN | DATABASE_CHARACTER | DATABASE_WORLD | DATABASE_DBC | DATABASE_MODULE
    };

Constructor & Destructor Documentation

DatabaseLoader()

DatabaseLoader::DatabaseLoader	(	std::string const &	logger,
		uint32 const	defaultUpdateMask = 0,
		std::string_view	modulesList = {}
	)

    : _logger(logger),
    _modulesList(modulesList),
    _autoSetup(sConfigMgr->GetOption<bool>("Updates.AutoSetup", true)),
    _updateFlags(sConfigMgr->GetOption<uint32>("Updates.EnableDatabases", defaultUpdateMask)) { }

Member Function Documentation

AddDatabase()

template<class T >

template AC_DATABASE_API DatabaseLoader & DatabaseLoader::AddDatabase< ModuleDatabaseConnection >	(	DatabaseWorkerPool< T > &	pool,
		std::string const &	name
	)

{
    bool const updatesEnabledForThis = DBUpdater<T>::IsEnabled(_updateFlags);
 
    _open.push([this, name, updatesEnabledForThis, &pool]() -> bool
    {
        std::string const dbString = sConfigMgr->GetOption<std::string>(name + "DatabaseInfo", "");
        if (dbString.empty())
        {
            LOG_ERROR(_logger, "{}DatabaseInfo is not specified in configuration file!"
                      "\nSearch the wiki for ACE00047 in Common Errors (https://www.azerothcore.org/wiki/common-errors#ace00043)", name);
            return false;
        }
 
        uint8 const asyncThreads = sConfigMgr->GetOption<uint8>(name + "Database.WorkerThreads", 1);
        if (asyncThreads < 1 || asyncThreads > 32)
        {
            LOG_ERROR(_logger, "{} database: invalid number of worker threads specified. "
                      "Please pick a value between 1 and 32.", name);
            return false;
        }
 
        uint8 const synchThreads = sConfigMgr->GetOption<uint8>(name + "Database.SynchThreads", 1);
 
        pool.SetConnectionInfo(dbString, asyncThreads, synchThreads);
 
        if (uint32 error = pool.Open())
        {
            // Try reconnect
            if (error == CR_CONNECTION_ERROR)
            {
                uint8 const attempts = sConfigMgr->GetOption<uint8>("Database.Reconnect.Attempts", 20);
                Seconds reconnectSeconds = Seconds(sConfigMgr->GetOption<uint8>("Database.Reconnect.Seconds", 15));
                uint8 reconnectCount = 0;
 
                while (reconnectCount < attempts)
                {
                    LOG_WARN(_logger, "> Retrying after {} seconds", static_cast<uint32>(reconnectSeconds.count()));
                    std::this_thread::sleep_for(reconnectSeconds);
                    error = pool.Open();
 
                    if (error == CR_CONNECTION_ERROR)
                    {
                        reconnectCount++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
 
            // Database does not exist
            if ((error == ER_BAD_DB_ERROR) && updatesEnabledForThis && _autoSetup)
            {
                // Try to create the database and connect again if auto setup is enabled
                if (DBUpdater<T>::Create(pool) && (!pool.Open()))
                {
                    error = 0;
                }
            }
 
            // If the error wasn't handled quit
            if (error)
            {
                LOG_ERROR(_logger, "DatabasePool {} NOT opened. There were errors opening the MySQL connections. "
                          "Check your log file for specific errors", name);
 
                return false;
            }
        }
        // Add the close operation
        _close.push([&pool]
        {
            pool.Close();
        });
 
        return true;
    });
 
    // Populate and update only if updates are enabled for this pool
    if (updatesEnabledForThis)
    {
        _populate.push([this, name, &pool]() -> bool
        {
            if (!DBUpdater<T>::Populate(pool))
            {
                LOG_ERROR(_logger, "Could not populate the {} database, see log for details.", name);
                return false;
            }
 
            return true;
        });
 
        _update.push([this, name, &pool]() -> bool
        {
            if (!DBUpdater<T>::Update(pool, _modulesList))
            {
                LOG_ERROR(_logger, "Could not update the {} database, see log for details.", name);
                return false;
            }
 
            return true;
        });
    }
 
    _prepare.push([this, name, &pool]() -> bool
    {
        if (!pool.PrepareStatements())
        {
            LOG_ERROR(_logger, "Could not prepare statements of the {} database, see log for details.", name);
            return false;
        }
 
        return true;
    });
 
    return *this;
}

References _autoSetup, _close, _logger, _modulesList, _open, _populate, _prepare, _update, _updateFlags, DatabaseWorkerPool< T >::Close(), DBUpdater< T >::IsEnabled(), LOG_ERROR, LOG_WARN, DatabaseWorkerPool< T >::Open(), DatabaseWorkerPool< T >::PrepareStatements(), sConfigMgr, and DatabaseWorkerPool< T >::SetConnectionInfo().

Referenced by StartDB().

GetUpdateFlags()

uint32 DatabaseLoader::GetUpdateFlags ( ) const

inline

    {
        return _updateFlags;
    }

Referenced by StartDB().

Load()

bool DatabaseLoader::Load

(

)

{
    if (!_updateFlags)
        LOG_INFO("sql.updates", "Automatic database updates are disabled for all databases!");
 
    if (!OpenDatabases())
        return false;
 
    if (!PopulateDatabases())
        return false;
 
    if (!UpdateDatabases())
        return false;
 
    if (!PrepareStatements())
        return false;
 
    return true;
}

References _updateFlags, LOG_INFO, OpenDatabases(), PopulateDatabases(), PrepareStatements(), and UpdateDatabases().

Referenced by StartDB().

OpenDatabases()

bool DatabaseLoader::OpenDatabases ( )

private

{
    return Process(_open);
}

References _open, and Process().

Referenced by Load().

PopulateDatabases()

bool DatabaseLoader::PopulateDatabases ( )

private

{
    return Process(_populate);
}

References _populate, and Process().

Referenced by Load().

PrepareStatements()

bool DatabaseLoader::PrepareStatements ( )

private

{
    return Process(_prepare);
}

References _prepare, and Process().

Referenced by Load().

Process()

bool DatabaseLoader::Process ( std::queue< Predicate > &  queue )

private

{
    while (!queue.empty())
    {
        if (!queue.front()())
        {
            // Close all open databases which have a registered close operation
            while (!_close.empty())
            {
                _close.top()();
                _close.pop();
            }
 
            return false;
        }
 
        queue.pop();
    }
 
    return true;
}

References _close.

Referenced by OpenDatabases(), PopulateDatabases(), PrepareStatements(), and UpdateDatabases().

UpdateDatabases()

bool DatabaseLoader::UpdateDatabases ( )

private

{
    return Process(_update);
}

References _update, and Process().

Referenced by Load().

Member Data Documentation

_autoSetup

bool const DatabaseLoader::_autoSetup

private

Referenced by AddDatabase().

_close

std::stack<Closer> DatabaseLoader::_close

private

Referenced by AddDatabase(), and Process().

_logger

std::string const DatabaseLoader::_logger

private

Referenced by AddDatabase().

_modulesList

std::string_view DatabaseLoader::_modulesList

private

Referenced by AddDatabase().

_open

std::queue<Predicate> DatabaseLoader::_open

private

Referenced by AddDatabase(), and OpenDatabases().

_populate

std::queue<Predicate> DatabaseLoader::_populate

private

Referenced by AddDatabase(), and PopulateDatabases().

_prepare

std::queue<Predicate> DatabaseLoader::_prepare

private

Referenced by AddDatabase(), and PrepareStatements().

_update

std::queue<Predicate> DatabaseLoader::_update

private

Referenced by AddDatabase(), and UpdateDatabases().

_updateFlags

uint32 const DatabaseLoader::_updateFlags

private

Referenced by AddDatabase(), and Load().