DBUpdater< T > Class Template Reference

#include "DBUpdater.h"

Public Types
using	Path = std::filesystem::path

Public Member Functions
std::string	GetConfigEntry ()
std::string	GetTableName ()
std::string	GetBaseFilesDirectory ()
bool	IsEnabled (uint32 const updateMask)
std::string	GetDBModuleName ()
std::string	GetConfigEntry ()
std::string	GetTableName ()
std::string	GetBaseFilesDirectory ()
bool	IsEnabled (uint32 const updateMask)
std::string	GetDBModuleName ()
std::string	GetConfigEntry ()
std::string	GetTableName ()
std::string	GetBaseFilesDirectory ()
bool	IsEnabled (uint32 const updateMask)
std::string	GetDBModuleName ()

Static Public Member Functions
static std::string	GetConfigEntry ()
static std::string	GetTableName ()
static std::string	GetBaseFilesDirectory ()
static bool	IsEnabled (uint32 const updateMask)
static BaseLocation	GetBaseLocationType ()
static bool	Create (DatabaseWorkerPool< T > &pool)
static bool	Update (DatabaseWorkerPool< T > &pool, std::string_view modulesList={})
static bool	Update (DatabaseWorkerPool< T > &pool, std::vector< std::string > const *setDirectories)
static bool	Populate (DatabaseWorkerPool< T > &pool)
static std::string	GetDBModuleName ()

Static Private Member Functions
static QueryResult	Retrieve (DatabaseWorkerPool< T > &pool, std::string const &query)
static void	Apply (DatabaseWorkerPool< T > &pool, std::string const &query)
static void	ApplyFile (DatabaseWorkerPool< T > &pool, Path const &path)
static void	ApplyFile (DatabaseWorkerPool< T > &pool, std::string const &host, std::string const &user, std::string const &password, std::string const &port_or_socket, std::string const &database, std::string const &ssl, Path const &path)

Detailed Description

template<class T>
class DBUpdater< T >

Member Typedef Documentation

Path

template<class T >

using DBUpdater< T >::Path = std::filesystem::path

Member Function Documentation

Apply()

template<class T >

void DBUpdater< T >::Apply ( DatabaseWorkerPool< T > &  pool, std::string const &  query  )

staticprivate

{
    pool.DirectExecute(query.c_str());
}

References DatabaseWorkerPool< T >::DirectExecute().

Referenced by DBUpdater< T >::Update().

ApplyFile() [1/2]

template<class T >

void DBUpdater< T >::ApplyFile ( DatabaseWorkerPool< T > &  pool, Path const &  path  )

staticprivate

{
    DBUpdater<T>::ApplyFile(pool, pool.GetConnectionInfo()->host, pool.GetConnectionInfo()->user, pool.GetConnectionInfo()->password,
                            pool.GetConnectionInfo()->port_or_socket, pool.GetConnectionInfo()->database, pool.GetConnectionInfo()->ssl, path);
}

References DBUpdater< T >::ApplyFile(), MySQLConnectionInfo::database, DatabaseWorkerPool< T >::GetConnectionInfo(), MySQLConnectionInfo::host, MySQLConnectionInfo::password, MySQLConnectionInfo::port_or_socket, MySQLConnectionInfo::ssl, and MySQLConnectionInfo::user.

Referenced by DBUpdater< T >::ApplyFile(), DBUpdater< T >::Create(), and DBUpdater< T >::Update().

ApplyFile() [2/2]

template<class T >

void DBUpdater< T >::ApplyFile ( DatabaseWorkerPool< T > &  pool, std::string const &  host, std::string const &  user, std::string const &  password, std::string const &  port_or_socket, std::string const &  database, std::string const &  ssl, Path const &  path  )

staticprivate

{
    std::string configTempDir = sConfigMgr->GetOption<std::string>("TempDir", "");
 
    auto tempDir = configTempDir.empty() ? std::filesystem::temp_directory_path().string() : configTempDir;
 
    tempDir = Acore::String::AddSuffixIfNotExists(tempDir, std::filesystem::path::preferred_separator);
 
    std::string confFileName = "mysql_ac.conf";
 
    std::ofstream outfile (tempDir + confFileName);
 
    outfile << "[client]\npassword = \"" << password << '"' << std::endl;
 
    outfile.close();
 
    std::vector<std::string> args;
    args.reserve(9);
 
    args.emplace_back("--defaults-extra-file="+tempDir + confFileName+"");
 
    // CLI Client connection info
    args.emplace_back("-h" + host);
    args.emplace_back("-u" + user);
 
    // Check if we want to connect through ip or socket (Unix only)
#ifdef _WIN32
 
    if (host == ".")
        args.emplace_back("--protocol=PIPE");
    else
        args.emplace_back("-P" + port_or_socket);
 
#else
 
    if (!std::isdigit(port_or_socket[0]))
    {
        // We can't check if host == "." here, because it is named localhost if socket option is enabled
        args.emplace_back("-P0");
        args.emplace_back("--protocol=SOCKET");
        args.emplace_back("-S" + port_or_socket);
    }
    else
        // generic case
        args.emplace_back("-P" + port_or_socket);
 
#endif
 
    // Set the default charset to utf8
    args.emplace_back("--default-character-set=utf8");
 
    // Set max allowed packet to 1 GB
    args.emplace_back("--max-allowed-packet=1GB");
 
#if !defined(MARIADB_VERSION_ID) && MYSQL_VERSION_ID >= 80000
 
    if (ssl == "ssl")
        args.emplace_back("--ssl-mode=REQUIRED");
 
#else
 
    if (ssl == "ssl")
        args.emplace_back("--ssl");
 
#endif
 
    // Execute sql file
    args.emplace_back("-e");
    args.emplace_back(Acore::StringFormat("BEGIN; SOURCE %s; COMMIT;", path.generic_string().c_str()));
 
    // Database
    if (!database.empty())
        args.emplace_back(database);
 
    // Invokes a mysql process which doesn't leak credentials to logs
    int const ret = Acore::StartProcess(DBUpdaterUtil::GetCorrectedMySQLExecutable(), args,
        "sql.updates", "", true);
 
    if (ret != EXIT_SUCCESS)
    {
        LOG_FATAL("sql.updates", "Applying of file \'{}\' to database \'{}\' failed!" \
            " If you are a user, please pull the latest revision from the repository. "
            "Also make sure you have not applied any of the databases with your sql client. "
            "You cannot use auto-update system and import sql files from AzerothCore repository with your sql client. "
            "If you are a developer, please fix your sql query.",
            path.generic_string(), pool.GetConnectionInfo()->database);
 
        throw UpdateException("update failed");
    }
}

References Acore::String::AddSuffixIfNotExists(), MySQLConnectionInfo::database, DatabaseWorkerPool< T >::GetConnectionInfo(), DBUpdaterUtil::GetCorrectedMySQLExecutable(), LOG_FATAL, sConfigMgr, Acore::StartProcess(), and Acore::StringFormat().

Create()

template<class T >

bool DBUpdater< T >::Create ( DatabaseWorkerPool< T > &  pool )

static

{
    LOG_WARN("sql.updates", "Database \"{}\" does not exist", pool.GetConnectionInfo()->database);
 
    const char* disableInteractive = std::getenv("AC_DISABLE_INTERACTIVE");
 
    if (!sConfigMgr->isDryRun() && (disableInteractive == nullptr || std::strcmp(disableInteractive, "1") != 0))
    {
        std::cout << "Do you want to create it? [yes (default) / no]:" << std::endl;
        std::string answer;
        std::getline(std::cin, answer);
        if (!answer.empty() && !(answer.substr(0, 1) == "y"))
            return false;
    }
 
    LOG_INFO("sql.updates", "Creating database \"{}\"...", pool.GetConnectionInfo()->database);
 
    // Path of temp file
    static Path const temp("create_table.sql");
 
    // Create temporary query to use external MySQL CLi
    std::ofstream file(temp.generic_string());
    if (!file.is_open())
    {
        LOG_FATAL("sql.updates", "Failed to create temporary query file \"{}\"!", temp.generic_string());
        return false;
    }
 
    file << "CREATE DATABASE `" << pool.GetConnectionInfo()->database << "` DEFAULT CHARACTER SET UTF8MB4 COLLATE utf8mb4_general_ci;\n\n";
    file.close();
 
    try
    {
        DBUpdater<T>::ApplyFile(pool, pool.GetConnectionInfo()->host, pool.GetConnectionInfo()->user, pool.GetConnectionInfo()->password,
                                pool.GetConnectionInfo()->port_or_socket, "", pool.GetConnectionInfo()->ssl, temp);
    }
    catch (UpdateException&)
    {
        LOG_FATAL("sql.updates", "Failed to create database {}! Does the user (named in *.conf) have `CREATE`, `ALTER`, `DROP`, `INSERT` and `DELETE` privileges on the MySQL server?", pool.GetConnectionInfo()->database);
        std::filesystem::remove(temp);
        return false;
    }
 
    LOG_INFO("sql.updates", "Done.");
    LOG_INFO("sql.updates", " ");
    std::filesystem::remove(temp);
    return true;
}

References DBUpdater< T >::ApplyFile(), MySQLConnectionInfo::database, DatabaseWorkerPool< T >::GetConnectionInfo(), MySQLConnectionInfo::host, LOG_FATAL, LOG_INFO, LOG_WARN, MySQLConnectionInfo::password, MySQLConnectionInfo::port_or_socket, sConfigMgr, MySQLConnectionInfo::ssl, and MySQLConnectionInfo::user.

GetBaseFilesDirectory() [1/4]

std::string DBUpdater< LoginDatabaseConnection >::GetBaseFilesDirectory

(

)

{
    return BuiltInConfig::GetSourceDirectory() + "/data/sql/base/db_auth/";
}

References BuiltInConfig::GetSourceDirectory().

GetBaseFilesDirectory() [2/4]

std::string DBUpdater< WorldDatabaseConnection >::GetBaseFilesDirectory

(

)

{
    return BuiltInConfig::GetSourceDirectory() + "/data/sql/base/db_world/";
}

References BuiltInConfig::GetSourceDirectory().

GetBaseFilesDirectory() [3/4]

std::string DBUpdater< CharacterDatabaseConnection >::GetBaseFilesDirectory

(

)

{
    return BuiltInConfig::GetSourceDirectory() + "/data/sql/base/db_characters/";
}

References BuiltInConfig::GetSourceDirectory().

GetBaseFilesDirectory() [4/4]

template<class T >

static std::string DBUpdater< T >::GetBaseFilesDirectory ( )

static

Referenced by DBUpdater< T >::Populate().

GetBaseLocationType()

template<class T >

BaseLocation DBUpdater< T >::GetBaseLocationType

static

{
    return LOCATION_REPOSITORY;
}

References LOCATION_REPOSITORY.

GetConfigEntry() [1/4]

std::string DBUpdater< LoginDatabaseConnection >::GetConfigEntry

(

)

{
    return "Updates.Auth";
}

GetConfigEntry() [2/4]

std::string DBUpdater< WorldDatabaseConnection >::GetConfigEntry

(

)

{
    return "Updates.World";
}

GetConfigEntry() [3/4]

std::string DBUpdater< CharacterDatabaseConnection >::GetConfigEntry

(

)

{
    return "Updates.Character";
}

GetConfigEntry() [4/4]

template<class T >

static std::string DBUpdater< T >::GetConfigEntry ( )

inlinestatic

GetDBModuleName() [1/4]

std::string DBUpdater< LoginDatabaseConnection >::GetDBModuleName

(

)

{
    return "db-auth";
}

GetDBModuleName() [2/4]

std::string DBUpdater< WorldDatabaseConnection >::GetDBModuleName

(

)

{
    return "db-world";
}

GetDBModuleName() [3/4]

std::string DBUpdater< CharacterDatabaseConnection >::GetDBModuleName

(

)

{
    return "db-characters";
}

GetDBModuleName() [4/4]

template<class T >

static std::string DBUpdater< T >::GetDBModuleName ( )

static

Referenced by DBUpdater< T >::Update().

GetTableName() [1/4]

std::string DBUpdater< LoginDatabaseConnection >::GetTableName

(

)

{
    return "Auth";
}

GetTableName() [2/4]

std::string DBUpdater< WorldDatabaseConnection >::GetTableName

(

)

{
    return "World";
}

GetTableName() [3/4]

std::string DBUpdater< CharacterDatabaseConnection >::GetTableName

(

)

{
    return "Character";
}

GetTableName() [4/4]

template<class T >

static std::string DBUpdater< T >::GetTableName ( )

inlinestatic

IsEnabled() [1/4]

bool DBUpdater< LoginDatabaseConnection >::IsEnabled

(

uint32 const

updateMask

)

{
    // This way silences warnings under msvc
    return (updateMask & DatabaseLoader::DATABASE_LOGIN) ? true : false;
}

References DatabaseLoader::DATABASE_LOGIN.

IsEnabled() [2/4]

bool DBUpdater< WorldDatabaseConnection >::IsEnabled

(

uint32 const

updateMask

)

{
    // This way silences warnings under msvc
    return (updateMask & DatabaseLoader::DATABASE_WORLD) ? true : false;
}

References DatabaseLoader::DATABASE_WORLD.

IsEnabled() [3/4]

bool DBUpdater< CharacterDatabaseConnection >::IsEnabled

(

uint32 const

updateMask

)

{
    // This way silences warnings under msvc
    return (updateMask & DatabaseLoader::DATABASE_CHARACTER) ? true : false;
}

References DatabaseLoader::DATABASE_CHARACTER.

IsEnabled() [4/4]

template<class T >

static bool DBUpdater< T >::IsEnabled ( uint32 const  updateMask )

static

Referenced by DatabaseLoader::AddDatabase().

Populate()

template<class T >

bool DBUpdater< T >::Populate ( DatabaseWorkerPool< T > &  pool )

static

{
    {
        QueryResult const result = Retrieve(pool, "SHOW TABLES");
        if (result && (result->GetRowCount() > 0))
            return true;
    }
 
    if (!DBUpdaterUtil::CheckExecutable())
        return false;
 
    LOG_INFO("sql.updates", "Database {} is empty, auto populating it...", DBUpdater<T>::GetTableName());
 
    std::string const DirPathStr = DBUpdater<T>::GetBaseFilesDirectory();
 
    Path const DirPath(DirPathStr);
    if (!std::filesystem::is_directory(DirPath))
    {
        LOG_ERROR("sql.updates", ">> Directory \"{}\" not exist", DirPath.generic_string());
        return false;
    }
 
    if (DirPath.empty())
    {
        LOG_ERROR("sql.updates", ">> Directory \"{}\" is empty", DirPath.generic_string());
        return false;
    }
 
    std::filesystem::directory_iterator const DirItr;
    uint32 FilesCount = 0;
 
    for (std::filesystem::directory_iterator itr(DirPath); itr != DirItr; ++itr)
    {
        if (itr->path().extension() == ".sql")
            FilesCount++;
    }
 
    if (!FilesCount)
    {
        LOG_ERROR("sql.updates", ">> In directory \"{}\" not exist '*.sql' files", DirPath.generic_string());
        return false;
    }
 
    for (std::filesystem::directory_iterator itr(DirPath); itr != DirItr; ++itr)
    {
        if (itr->path().extension() != ".sql")
            continue;
 
        LOG_INFO("sql.updates", ">> Applying \'{}\'...", itr->path().filename().generic_string());
 
        try
        {
            ApplyFile(pool, itr->path());
        }
        catch (UpdateException&)
        {
            return false;
        }
    }
 
    LOG_INFO("sql.updates", ">> Done!");
    LOG_INFO("sql.updates", " ");
    return true;
}

References DBUpdaterUtil::CheckExecutable(), DBUpdater< T >::GetBaseFilesDirectory(), LOG_ERROR, and LOG_INFO.

Retrieve()

template<class T >

QueryResult DBUpdater< T >::Retrieve ( DatabaseWorkerPool< T > &  pool, std::string const &  query  )

staticprivate

{
    return pool.Query(query.c_str());
}

References DatabaseWorkerPool< T >::Query().

Referenced by DBUpdater< T >::Update().

Update() [1/2]

template<class T >

bool DBUpdater< T >::Update ( DatabaseWorkerPool< T > &  pool, std::string_view  modulesList = {}  )

static

{
    if (!DBUpdaterUtil::CheckExecutable())
        return false;
 
    LOG_INFO("sql.updates", "Updating {} database...", DBUpdater<T>::GetTableName());
 
    Path const sourceDirectory(BuiltInConfig::GetSourceDirectory());
 
    if (!is_directory(sourceDirectory))
    {
        LOG_ERROR("sql.updates", "DBUpdater: The given source directory {} does not exist, change the path to the directory where your sql directory exists (for example c:\\source\\trinitycore). Shutting down.",
                  sourceDirectory.generic_string());
        return false;
    }
 
    auto CheckUpdateTable = [&](std::string const& tableName)
    {
        auto checkTable = DBUpdater<T>::Retrieve(pool, Acore::StringFormatFmt("SHOW TABLES LIKE '{}'", tableName));
        if (!checkTable)
        {
            LOG_WARN("sql.updates", "> Table '{}' not exist! Try add based table", tableName);
 
            Path const temp(GetBaseFilesDirectory() + tableName + ".sql");
 
            try
            {
                DBUpdater<T>::ApplyFile(pool, temp);
            }
            catch (UpdateException&)
            {
                LOG_FATAL("sql.updates", "Failed apply file to database {}! Does the user (named in *.conf) have `INSERT` and `DELETE` privileges on the MySQL server?", pool.GetConnectionInfo()->database);
                return false;
            }
 
            return true;
        }
 
        return true;
    };
 
    if (!CheckUpdateTable("updates") || !CheckUpdateTable("updates_include"))
        return false;
 
    UpdateFetcher updateFetcher(sourceDirectory, [&](std::string const & query) { DBUpdater<T>::Apply(pool, query); },
    [&](Path const & file) { DBUpdater<T>::ApplyFile(pool, file); },
    [&](std::string const & query) -> QueryResult { return DBUpdater<T>::Retrieve(pool, query); }, DBUpdater<T>::GetDBModuleName(), modulesList);
 
    UpdateResult result;
    try
    {
        result = updateFetcher.Update(
                     sConfigMgr->GetOption<bool>("Updates.Redundancy", true),
                     sConfigMgr->GetOption<bool>("Updates.AllowRehash", true),
                     sConfigMgr->GetOption<bool>("Updates.ArchivedRedundancy", false),
                     sConfigMgr->GetOption<int32>("Updates.CleanDeadRefMaxCount", 3));
    }
    catch (UpdateException&)
    {
        return false;
    }
 
    std::string const info = Acore::StringFormatFmt("Containing {} new and {} archived updates.", result.recent, result.archived);
 
    if (!result.updated)
        LOG_INFO("sql.updates", ">> {} database is up-to-date! {}", DBUpdater<T>::GetTableName(), info);
    else
        LOG_INFO("sql.updates", ">> Applied {} {}. {}", result.updated, result.updated == 1 ? "query" : "queries", info);
 
    LOG_INFO("sql.updates", " ");
 
    return true;
}

References DBUpdater< T >::Apply(), DBUpdater< T >::ApplyFile(), DBUpdaterUtil::CheckExecutable(), MySQLConnectionInfo::database, DatabaseWorkerPool< T >::GetConnectionInfo(), DBUpdater< T >::GetDBModuleName(), BuiltInConfig::GetSourceDirectory(), LOG_ERROR, LOG_FATAL, LOG_INFO, LOG_WARN, DBUpdater< T >::Retrieve(), sConfigMgr, and Acore::StringFormatFmt().

Update() [2/2]

template<class T >

bool DBUpdater< T >::Update ( DatabaseWorkerPool< T > &  pool, std::vector< std::string > const *  setDirectories  )

static

{
    if (!DBUpdaterUtil::CheckExecutable())
    {
        return false;
    }
 
    Path const sourceDirectory(BuiltInConfig::GetSourceDirectory());
    if (!is_directory(sourceDirectory))
    {
        return false;
    }
 
    auto CheckUpdateTable = [&](std::string const& tableName)
    {
        auto checkTable = DBUpdater<T>::Retrieve(pool, Acore::StringFormatFmt("SHOW TABLES LIKE '{}'", tableName));
        if (!checkTable)
        {
            Path const temp(GetBaseFilesDirectory() + tableName + ".sql");
            try
            {
                DBUpdater<T>::ApplyFile(pool, temp);
            }
            catch (UpdateException&)
            {
                return false;
            }
 
            return true;
        }
 
        return true;
    };
 
    if (!CheckUpdateTable("updates") || !CheckUpdateTable("updates_include"))
    {
        return false;
    }
 
    UpdateFetcher updateFetcher(sourceDirectory, [&](std::string const & query) { DBUpdater<T>::Apply(pool, query); },
    [&](Path const & file) { DBUpdater<T>::ApplyFile(pool, file); },
    [&](std::string const & query) -> QueryResult { return DBUpdater<T>::Retrieve(pool, query); }, DBUpdater<T>::GetDBModuleName(), setDirectories);
 
    UpdateResult result;
    try
    {
        result = updateFetcher.Update(
                     sConfigMgr->GetOption<bool>("Updates.Redundancy", true),
                     sConfigMgr->GetOption<bool>("Updates.AllowRehash", true),
                     sConfigMgr->GetOption<bool>("Updates.ArchivedRedundancy", false),
                     sConfigMgr->GetOption<int32>("Updates.CleanDeadRefMaxCount", 3));
    }
    catch (UpdateException&)
    {
        return false;
    }
 
    return true;
}

References DBUpdater< T >::Apply(), DBUpdater< T >::ApplyFile(), DBUpdaterUtil::CheckExecutable(), DBUpdater< T >::GetDBModuleName(), BuiltInConfig::GetSourceDirectory(), DBUpdater< T >::Retrieve(), sConfigMgr, and Acore::StringFormatFmt().