Acore Daemon

Files
file	CliRunnable.cpp
file	CliRunnable.h
file	Main.cpp

Classes
class	FreezeDetector

Macros
#define	_ACORE_CORE_CONFIG   "worldserver.conf"

Functions
static void	PrintCliPrefix ()
void	utf8print (void *, std::string_view str)
void	commandFinished (void *, bool)
void	CliThread ()
	Thread start
	FreezeDetector::FreezeDetector (Acore::Asio::IoContext &ioContext, uint32 maxCoreStuckTime)
static void	FreezeDetector::Start (std::shared_ptr< FreezeDetector > const &freezeDetector)
static void	FreezeDetector::Handler (std::weak_ptr< FreezeDetector > freezeDetectorRef, boost::system::error_code const &error)
void	SignalHandler (boost::system::error_code const &error, int signalNumber)
void	ClearOnlineAccounts ()
	Clear 'online' status for all accounts with characters in this realm.
bool	StartDB ()
	Initialize connection to the databases.
void	StopDB ()
bool	LoadRealmInfo (Acore::Asio::IoContext &ioContext)
AsyncAcceptor *	StartRaSocketAcceptor (Acore::Asio::IoContext &ioContext)
void	ShutdownCLIThread (std::thread *cliThread)
void	WorldUpdateLoop ()
variables_map	GetConsoleArguments (int argc, char **argv, fs::path &configFile, std::string &cfg_service)
int	main (int argc, char **argv)
	Launch the Azeroth server.

Variables
static constexpr char	CLI_PREFIX [] = "AC> "
char	serviceName [] = "worldserver"
char	serviceLongName [] = "AzerothCore world service"
char	serviceDescription [] = "AzerothCore World of Warcraft emulator world service"
int	m_ServiceStatus = -1
boost::asio::steady_timer	FreezeDetector::_timer
uint32	FreezeDetector::_worldLoopCounter
uint32	FreezeDetector::_lastChangeMsTime
uint32	FreezeDetector::_maxCoreStuckTimeInMs

Detailed Description

Macro Definition Documentation

_ACORE_CORE_CONFIG

#define _ACORE_CORE_CONFIG   "worldserver.conf"

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

Function Documentation

ClearOnlineAccounts()

void ClearOnlineAccounts

(

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

Clear 'online' status for all accounts with characters in this realm.

{
    // Reset online status for all accounts with characters on the current realm
    // pussywizard: tc query would set online=0 even if logged in on another realm >_>
    LoginDatabase.DirectExecute("UPDATE account SET online = 0 WHERE online = {}", realm.Id.Realm);
 
    // Reset online status for all characters
    CharacterDatabase.DirectExecute("UPDATE characters SET online = 0 WHERE online <> 0");
}

References CharacterDatabase, Realm::Id, LoginDatabase, realm, and RealmHandle::Realm.

Referenced by main(), and StartDB().

CliThread()

void CliThread

(

)

#include <azerothcore-wotlk/src/server/apps/worldserver/CommandLine/CliRunnable.cpp>

Thread start

Command Line Interface handling thread.

• As long as the World is running (no World::m_stopEvent), get the command line and handle it

{
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    // Set console code pages to UTF-8
    SetConsoleCP(CP_UTF8);
    SetConsoleOutputCP(CP_UTF8);
 
    // print this here the first time
    // later it will be printed after command queue updates
    PrintCliPrefix();
#else
    ::rl_attempted_completion_function = &Acore::Impl::Readline::cli_completion;
    {
        static char BLANK = '\0';
        ::rl_completer_word_break_characters = ␣
    }
    ::rl_event_hook = &Acore::Impl::Readline::cli_hook_func;
#endif
 
    if (sConfigMgr->GetOption<bool>("BeepAtStart", true))
        printf("\a"); // \a = Alert
 
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    if (sConfigMgr->GetOption<bool>("FlashAtStart", true))
    {
        FLASHWINFO fInfo;
        fInfo.cbSize = sizeof(FLASHWINFO);
        fInfo.dwFlags = FLASHW_TRAY | FLASHW_TIMERNOFG;
        fInfo.hwnd = GetConsoleWindow();
        fInfo.uCount = 0;
        fInfo.dwTimeout = 0;
        FlashWindowEx(&fInfo);
    }
 
    // Get console input handle once for reading commands
    HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
    if (hStdIn == INVALID_HANDLE_VALUE)
    {
        LOG_ERROR("server.worldserver", "Failed to get console input handle");
        return;
    }
#endif
 
    while (!World::IsStopped())
    {
        fflush(stdout);
 
        std::string command;
 
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
 
        static bool checkedConsole = false;
        static bool isRealConsole = false;
 
        if (!checkedConsole)
        {
            DWORD mode = 0;
            isRealConsole = GetConsoleMode(hStdIn, &mode);
            checkedConsole = true;
        }
 
        if (isRealConsole)
        {
            // ===== Real Windows Console =====
            wchar_t commandbuf[256];
            DWORD charsRead = 0;
 
            if (ReadConsoleW(hStdIn, commandbuf,
                sizeof(commandbuf) / sizeof(wchar_t) - 1,
                &charsRead, nullptr))
            {
                if (charsRead > 0)
                {
                    commandbuf[charsRead] = L'\0';
                    if (!WStrToUtf8(commandbuf, charsRead, command))
                    {
                        PrintCliPrefix();
                        continue;
                    }
                }
            }
        }
        else
        {
            // ===== Redirected input (pipe) =====
            if (!std::getline(std::cin, command))
            {
                World::StopNow(SHUTDOWN_EXIT_CODE);
                break;
            }
        }
 
#else
        char* command_str = readline(CLI_PREFIX);
        ::rl_bind_key('\t', ::rl_complete);
        if (command_str != nullptr)
        {
            command = command_str;
            free(command_str);
        }
#endif
 
        if (!command.empty())
        {
            std::size_t nextLineIndex = command.find_first_of("\r\n");
            if (nextLineIndex != std::string::npos)
            {
                if (nextLineIndex == 0)
                {
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
                    PrintCliPrefix();
#endif
                    continue;
                }
 
                command.erase(nextLineIndex);
            }
 
            fflush(stdout);
            sWorld->QueueCliCommand(new CliCommandHolder(nullptr, command.c_str(), &utf8print, &commandFinished));
#if AC_PLATFORM != AC_PLATFORM_WINDOWS
            add_history(command.c_str());
#endif
        }
        else if (feof(stdin))
        {
            World::StopNow(SHUTDOWN_EXIT_CODE);
        }
    }
}

References CLI_PREFIX, commandFinished(), World::IsStopped(), LOG_ERROR, PrintCliPrefix(), sConfigMgr, SHUTDOWN_EXIT_CODE, World::StopNow(), sWorld, utf8print(), and WStrToUtf8().

Referenced by main().

commandFinished()

void commandFinished	(	void *	,
		bool
	)

#include <azerothcore-wotlk/src/server/apps/worldserver/CommandLine/CliRunnable.cpp>

{
    PrintCliPrefix();
    fflush(stdout);
}

References PrintCliPrefix().

Referenced by CliThread().

FreezeDetector()

FreezeDetector::FreezeDetector ( Acore::Asio::IoContext &  ioContext, uint32  maxCoreStuckTime  )

inline

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

        : _timer(ioContext), _worldLoopCounter(0), _lastChangeMsTime(getMSTime()), _maxCoreStuckTimeInMs(maxCoreStuckTime) { }

GetConsoleArguments()

variables_map GetConsoleArguments	(	int	argc,
		char **	argv,
		fs::path &	configFile,
		std::string &	cfg_service
	)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    options_description all("Allowed options");
    all.add_options()
        ("help,h", "print usage message")
        ("version,v", "print version build info")
        ("dry-run,d", "Dry run")
        ("config,c", value<fs::path>(&configFile)->default_value(fs::path(sConfigMgr->GetConfigPath() + std::string(_ACORE_CORE_CONFIG))), "use <arg> as configuration file")
        ("config-policy", value<std::string>()->value_name("policy"), "override config severity policy (e.g. default=skip,critical_option=fatal)");
 
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    options_description win("Windows platform specific options");
    win.add_options()
        ("service,s", value<std::string>(&configService)->default_value(""), "Windows service options: [install | uninstall]");
 
    all.add(win);
#endif
 
    variables_map vm;
 
    try
    {
        store(command_line_parser(argc, argv).options(all).allow_unregistered().run(), vm);
        notify(vm);
    }
    catch (std::exception const& e)
    {
        std::cerr << e.what() << "\n";
    }
 
    if (vm.count("help"))
        std::cout << all << "\n";
    else if (vm.count("version"))
        std::cout << GitRevision::GetFullVersion() << "\n";
    else if (vm.count("dry-run"))
        sConfigMgr->setDryRun(true);
 
    return vm;
}

References _ACORE_CORE_CONFIG, GitRevision::GetFullVersion(), and sConfigMgr.

Referenced by main().

Handler()

void FreezeDetector::Handler ( std::weak_ptr< FreezeDetector >  freezeDetectorRef, boost::system::error_code const &  error  )

static

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    if (!error)
    {
        if (std::shared_ptr<FreezeDetector> freezeDetector = freezeDetectorRef.lock())
        {
            uint32 curtime = getMSTime();
 
            uint32 worldLoopCounter = World::m_worldLoopCounter;
            if (freezeDetector->_worldLoopCounter != worldLoopCounter)
            {
                freezeDetector->_lastChangeMsTime = curtime;
                freezeDetector->_worldLoopCounter = worldLoopCounter;
            }
            // possible freeze
            else
            {
                uint32 msTimeDiff = getMSTimeDiff(freezeDetector->_lastChangeMsTime, curtime);
                if (msTimeDiff > freezeDetector->_maxCoreStuckTimeInMs)
                {
                    LOG_ERROR("server.worldserver", "World Thread hangs for {} ms, forcing a crash!", msTimeDiff);
                    ABORT("World Thread hangs for {} ms, forcing a crash!", msTimeDiff);
                }
            }
 
            freezeDetector->_timer.expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(1));
            freezeDetector->_timer.async_wait(std::bind(&FreezeDetector::Handler, freezeDetectorRef, std::placeholders::_1));
        }
    }
}

References ABORT, Acore::Asio::SteadyTimer::GetExpirationTime(), getMSTime(), getMSTimeDiff(), FreezeDetector::Handler(), LOG_ERROR, and World::m_worldLoopCounter.

Referenced by FreezeDetector::Handler(), and FreezeDetector::Start().

LoadRealmInfo()

bool LoadRealmInfo

(

Acore::Asio::IoContext &

ioContext

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    QueryResult result = LoginDatabase.Query("SELECT id, name, address, localAddress, localSubnetMask, port, icon, flag, timezone, allowedSecurityLevel, population, gamebuild FROM realmlist WHERE id = {}", realm.Id.Realm);
    if (!result)
        return false;
 
    Acore::Asio::Resolver resolver(ioContext);
 
    Field* fields = result->Fetch();
    realm.Name = fields[1].Get<std::string>();
 
    Optional<boost::asio::ip::tcp::endpoint> externalAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[2].Get<std::string>(), "");
    if (!externalAddress)
    {
        LOG_ERROR("server.worldserver", "Could not resolve address {}", fields[2].Get<std::string>());
        return false;
    }
 
    realm.ExternalAddress = std::make_unique<boost::asio::ip::address>(externalAddress->address());
 
    Optional<boost::asio::ip::tcp::endpoint> localAddress = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[3].Get<std::string>(), "");
    if (!localAddress)
    {
        LOG_ERROR("server.worldserver", "Could not resolve address {}", fields[3].Get<std::string>());
        return false;
    }
 
    realm.LocalAddress = std::make_unique<boost::asio::ip::address>(localAddress->address());
 
    Optional<boost::asio::ip::tcp::endpoint> localSubmask = resolver.Resolve(boost::asio::ip::tcp::v4(), fields[4].Get<std::string>(), "");
    if (!localSubmask)
    {
        LOG_ERROR("server.worldserver", "Could not resolve address {}", fields[4].Get<std::string>());
        return false;
    }
 
    realm.LocalSubnetMask = std::make_unique<boost::asio::ip::address>(localSubmask->address());
 
    realm.Port = fields[5].Get<uint16>();
    realm.Type = fields[6].Get<uint8>();
    realm.Flags = RealmFlags(fields[7].Get<uint8>());
    realm.Timezone = fields[8].Get<uint8>();
    realm.AllowedSecurityLevel = AccountTypes(fields[9].Get<uint8>());
    realm.PopulationLevel = fields[10].Get<float>();
    realm.Build = fields[11].Get<uint32>();
    return true;
}

References Realm::AllowedSecurityLevel, Realm::Build, Realm::ExternalAddress, Realm::Flags, Field::Get(), Realm::Id, Realm::LocalAddress, Realm::LocalSubnetMask, LOG_ERROR, LoginDatabase, Realm::Name, Realm::PopulationLevel, Realm::Port, realm, RealmHandle::Realm, Acore::Asio::Resolver::Resolve(), Realm::Timezone, and Realm::Type.

Referenced by main().

main()

int main	(	int	argc,
		char **	argv
	)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

Launch the Azeroth server.

worldserver PID file creation

• Initialize the World

• Clean database before leaving

{
    Acore::Impl::CurrentServerProcessHolder::_type = SERVER_PROCESS_WORLDSERVER;
    signal(SIGABRT, &Acore::AbortHandler);
 
    // Command line parsing
    auto configFile = fs::path(sConfigMgr->GetConfigPath() + std::string(_ACORE_CORE_CONFIG));
    std::string configService;
    auto vm = GetConsoleArguments(argc, argv, configFile, configService);
 
    // exit if help or version is enabled
    if (vm.count("help") || vm.count("version"))
        return 0;
 
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    if (configService.compare("install") == 0)
        return WinServiceInstall() == true ? 0 : 1;
    else if (configService.compare("uninstall") == 0)
        return WinServiceUninstall() == true ? 0 : 1;
    else if (configService.compare("run") == 0)
        WinServiceRun();
 
    Optional<UINT> newTimerResolution;
    boost::system::error_code dllError;
    std::shared_ptr<boost::dll::shared_library> winmm(new boost::dll::shared_library("winmm.dll", dllError, boost::dll::load_mode::search_system_folders), [&](boost::dll::shared_library* lib)
    {
        try
        {
            if (newTimerResolution)
                lib->get<decltype(timeEndPeriod)>("timeEndPeriod")(*newTimerResolution);
        }
        catch (std::exception const&)
        {
            // ignore
        }
 
        delete lib;
    });
 
    if (winmm->is_loaded())
    {
        try
        {
            auto timeGetDevCapsPtr = winmm->get<decltype(timeGetDevCaps)>("timeGetDevCaps");
            // setup timer resolution
            TIMECAPS timeResolutionLimits;
            if (timeGetDevCapsPtr(&timeResolutionLimits, sizeof(TIMECAPS)) == TIMERR_NOERROR)
            {
                auto timeBeginPeriodPtr = winmm->get<decltype(timeBeginPeriod)>("timeBeginPeriod");
                newTimerResolution = std::min(std::max(timeResolutionLimits.wPeriodMin, 1u), timeResolutionLimits.wPeriodMax);
                timeBeginPeriodPtr(*newTimerResolution);
            }
        }
        catch (std::exception const& e)
        {
            printf("Failed to initialize timer resolution: %s\n", e.what());
        }
    }
 
#endif
 
    // Add file and args in config
    sConfigMgr->Configure(configFile.generic_string(), {argv, argv + argc}, CONFIG_FILE_LIST);
 
    if (!sConfigMgr->LoadAppConfigs())
        return 1;
 
    std::shared_ptr<Acore::Asio::IoContext> ioContext = std::make_shared<Acore::Asio::IoContext>();
 
    // Init all logs
    sLog->RegisterAppender<AppenderDB>();
    // If logs are supposed to be handled async then we need to pass the IoContext into the Log singleton
    sLog->Initialize(sConfigMgr->GetOption<bool>("Log.Async.Enable", false) ? ioContext.get() : nullptr);
 
    Acore::Banner::Show("worldserver-daemon",
        [](std::string_view text)
        {
            LOG_INFO("server.worldserver", text);
        },
        []()
        {
            LOG_INFO("server.worldserver", "> Using configuration file       {}", sConfigMgr->GetFilename());
            LOG_INFO("server.worldserver", "> Using SSL version:             {} (library: {})", OPENSSL_VERSION_TEXT, OpenSSL_version(OPENSSL_VERSION));
            LOG_INFO("server.worldserver", "> Using Boost version:           {}.{}.{}", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);
        });
 
    // Cluster.Enabled is known from config here. Fail before DB/network if the
    // loaded libsidecar is the stub or does not match the headers we built with.
    if (!sToCloud9Sidecar->CheckLibsidecarAbi())
        return 1;
 
    OpenSSLCrypto::threadsSetup();
 
    std::shared_ptr<void> opensslHandle(nullptr, [](void*) { OpenSSLCrypto::threadsCleanup(); });
 
    // Seed the OpenSSL's PRNG here.
    // That way it won't auto-seed when calling BigNumber::SetRand and slow down the first world login
    BigNumber seed;
    seed.SetRand(16 * 8);
 
    std::string pidFile = sConfigMgr->GetOption<std::string>("PidFile", "");
    if (!pidFile.empty())
    {
        if (uint32 pid = CreatePIDFile(pidFile))
            LOG_ERROR("server", "Daemon PID: {}\n", pid); // outError for red color in console
        else
        {
            LOG_ERROR("server", "Cannot create PID file {} (possible error: permission)\n", pidFile);
            return 1;
        }
    }
 
    // Set signal handlers (this must be done before starting IoContext threads, because otherwise they would unblock and exit)
    boost::asio::signal_set signals(*ioContext, SIGINT, SIGTERM);
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    signals.add(SIGBREAK);
#endif
    signals.async_wait(SignalHandler);
 
    // Start the Boost based thread pool
    int numThreads = sConfigMgr->GetOption<int32>("ThreadPool", 2);
    std::shared_ptr<std::vector<std::thread>> threadPool(new std::vector<std::thread>(), [ioContext](std::vector<std::thread>* del)
    {
        ioContext->stop();
        for (std::thread& thr : *del)
            thr.join();
 
        delete del;
    });
 
    if (numThreads < 1)
    {
        numThreads = 1;
    }
 
    for (int i = 0; i < numThreads; ++i)
    {
        threadPool->push_back(std::thread([ioContext]()
        {
            ioContext->run();
        }));
    }
 
    // Set process priority according to configuration settings
    SetProcessPriority("server.worldserver", sConfigMgr->GetOption<int32>(CONFIG_PROCESSOR_AFFINITY, 0), sConfigMgr->GetOption<bool>(CONFIG_HIGH_PRIORITY, true));
 
    // Loading modules configs before scripts
    sConfigMgr->LoadModulesConfigs();
 
    sScriptMgr->SetScriptLoader(AddScripts);
    sScriptMgr->SetModulesLoader(AddModulesScripts);
 
    std::shared_ptr<void> sScriptMgrHandle(nullptr, [](void*)
    {
        sScriptMgr->Unload();
        //sScriptReloadMgr->Unload();
    });
 
    LOG_INFO("server.loading", "Initializing Scripts...");
    sScriptMgr->Initialize();
 
    // Start the databases
    if (!StartDB())
        return 1;
 
    std::shared_ptr<void> dbHandle(nullptr, [](void*) { StopDB(); });
 
    // Declared right after dbHandle so it runs after every other shutdown step; a crash before this leaves EndTime NULL
    std::shared_ptr<void> sessionEndHandle(nullptr, [](void*) { sWorld->SaveSessionEnd(true); });
 
    // set server offline (not connectable)
    LoginDatabase.DirectExecute("UPDATE realmlist SET flag = (flag & ~{}) | {} WHERE id = '{}'", REALM_FLAG_OFFLINE, REALM_FLAG_VERSION_MISMATCH, realm.Id.Realm);
 
    LoadRealmInfo(*ioContext);
 
    sMetric->Initialize(realm.Name, *ioContext, []()
    {
        METRIC_VALUE("online_players", sWorldSessionMgr->GetPlayerCount());
        METRIC_VALUE("db_queue_login", uint64(LoginDatabase.QueueSize()));
        METRIC_VALUE("db_queue_character", uint64(CharacterDatabase.QueueSize()));
        METRIC_VALUE("db_queue_world", uint64(WorldDatabase.QueueSize()));
    });
 
    METRIC_EVENT("events", "Worldserver started", "");
 
    std::shared_ptr<void> sMetricHandle(nullptr, [](void*)
    {
        METRIC_EVENT("events", "Worldserver shutdown", "");
        sMetric->Unload();
    });
 
    Acore::Module::SetEnableModulesList(AC_MODULES_LIST);
 
    sSecretMgr->Initialize();
    sWorld->SetInitialWorldSettings();
 
    std::shared_ptr<void> mapManagementHandle(nullptr, [](void*)
    {
        // unload battleground templates before different singletons destroyed
        sBattlegroundMgr->DeleteAllBattlegrounds();
 
        sOutdoorPvPMgr->Die();                     // unload it before MapMgr
        sMapMgr->UnloadAll();                      // unload all grids (including locked in memory)
 
        sScriptMgr->OnAfterUnloadAllMaps();
    });
 
    // Start the Remote Access port (acceptor) if enabled
    std::unique_ptr<AsyncAcceptor> raAcceptor;
    if (sConfigMgr->GetOption<bool>("Ra.Enable", false))
    {
        raAcceptor.reset(StartRaSocketAcceptor(*ioContext));
    }
 
    // Start soap serving thread if enabled
    std::shared_ptr<std::thread> soapThread;
    if (sConfigMgr->GetOption<bool>("SOAP.Enabled", false))
    {
        soapThread.reset(new std::thread(ACSoapThread, sConfigMgr->GetOption<std::string>("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetOption<int32>("SOAP.Port", 7878))),
            [](std::thread* thr)
        {
            thr->join();
            delete thr;
        });
    }
 
    // Launch the worldserver listener socket
    uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD));
    std::string worldListener = sConfigMgr->GetOption<std::string>("BindIP", "0.0.0.0");
 
    int networkThreads = sConfigMgr->GetOption<int32>("Network.Threads", 1);
 
    if (networkThreads <= 0)
    {
        LOG_ERROR("server.worldserver", "Network.Threads must be greater than 0");
        World::StopNow(ERROR_EXIT_CODE);
        return 1;
    }
 
    if (!sWorldSocketMgr.StartWorldNetwork(*ioContext, worldListener, worldPort, networkThreads))
    {
        LOG_ERROR("server.worldserver", "Failed to initialize network");
        World::StopNow(ERROR_EXIT_CODE);
        return 1;
    }
 
    std::shared_ptr<void> sWorldSocketMgrHandle(nullptr, [](void*)
    {
        sWorldSessionMgr->KickAll();         // save and kick all players
        sWorldSessionMgr->UpdateSessions(1); // real players unload required UpdateSessions call
 
        sWorldSocketMgr.StopNetwork();
 
        if (!sToCloud9Sidecar->ClusterModeEnabled())
            ClearOnlineAccounts();
    });
 
    // Set server online (allow connecting now)
    LoginDatabase.DirectExecute("UPDATE realmlist SET flag = flag & ~{}, population = 0 WHERE id = '{}'", REALM_FLAG_VERSION_MISMATCH, realm.Id.Realm);
    realm.PopulationLevel = 0.0f;
    realm.Flags = RealmFlags(realm.Flags & ~uint32(REALM_FLAG_VERSION_MISMATCH));
 
    // Start the freeze check callback cycle in 5 seconds (cycle itself is 1 sec)
    std::shared_ptr<FreezeDetector> freezeDetector;
    if (int32 coreStuckTime = sConfigMgr->GetOption<int32>("MaxCoreStuckTime", 60))
    {
        freezeDetector = std::make_shared<FreezeDetector>(*ioContext, coreStuckTime * 1000);
        FreezeDetector::Start(freezeDetector);
        LOG_INFO("server.worldserver", "Starting up anti-freeze thread ({} seconds max stuck time)...", coreStuckTime);
    }
 
    LOG_INFO("server.worldserver", "{} (worldserver-daemon) ready...", GitRevision::GetFullVersion());
 
    sScriptMgr->OnStartup();
 
    // Launch CliRunnable thread
    std::shared_ptr<std::thread> cliThread;
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    if (sConfigMgr->GetOption<bool>("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/)
#else
    if (sConfigMgr->GetOption<bool>("Console.Enable", true))
#endif
    {
        cliThread.reset(new std::thread(CliThread), &ShutdownCLIThread);
    }
 
    sToCloud9Sidecar->Init(worldPort, realm.Id.Realm);
 
    WorldUpdateLoop();
 
    // Shutdown starts here
    threadPool.reset();
 
    // Record the shutdown details now so a crash while saving players still reports them.
    // After threadPool.reset() no signal handler can run StopNow and change the exit code.
    sWorld->SaveSessionEnd(false);
 
    sToCloud9Sidecar->Deinit();
 
    sLog->SetSynchronous();
 
    sScriptMgr->OnShutdown();
 
    // set server offline
    if (!sConfigMgr->GetOption<bool>("Network.UseSocketActivation", false))
        LoginDatabase.DirectExecute("UPDATE realmlist SET flag = flag | {} WHERE id = '{}'", REALM_FLAG_OFFLINE, realm.Id.Realm);
 
    LOG_INFO("server.worldserver", "Halting process...");
 
    // 0 - normal shutdown
    // 1 - shutdown at error
    // 2 - restart command used, this code can be used by restarter for restart AzerothCore
 
    return World::GetExitCode();
}

References _ACORE_CORE_CONFIG, Acore::Impl::CurrentServerProcessHolder::_type, Acore::AbortHandler(), ACSoapThread(), AddScripts(), ClearOnlineAccounts(), CliThread(), CONFIG_HIGH_PRIORITY, CONFIG_PORT_WORLD, CONFIG_PROCESSOR_AFFINITY, CreatePIDFile(), ERROR_EXIT_CODE, Realm::Flags, GetConsoleArguments(), World::GetExitCode(), GitRevision::GetFullVersion(), Realm::Id, LoadRealmInfo(), LOG_ERROR, LOG_INFO, LoginDatabase, m_ServiceStatus, METRIC_EVENT, Realm::Name, Realm::PopulationLevel, realm, RealmHandle::Realm, REALM_FLAG_OFFLINE, REALM_FLAG_VERSION_MISMATCH, sBattlegroundMgr, sConfigMgr, SERVER_PROCESS_WORLDSERVER, Acore::Module::SetEnableModulesList(), SetProcessPriority(), BigNumber::SetRand(), Acore::Banner::Show(), ShutdownCLIThread(), SignalHandler(), sLog, sMapMgr, sMetric, sOutdoorPvPMgr, sScriptMgr, sSecretMgr, FreezeDetector::Start(), StartDB(), StartRaSocketAcceptor(), sToCloud9Sidecar, StopDB(), World::StopNow(), sWorld, sWorldSessionMgr, sWorldSocketMgr, OpenSSLCrypto::threadsCleanup(), OpenSSLCrypto::threadsSetup(), and WorldUpdateLoop().

PrintCliPrefix()

static void PrintCliPrefix ( )

inlinestatic

#include <azerothcore-wotlk/src/server/apps/worldserver/CommandLine/CliRunnable.cpp>

{
    fmt::print(CLI_PREFIX);
}

References CLI_PREFIX.

Referenced by CliThread(), and commandFinished().

ShutdownCLIThread()

void ShutdownCLIThread

(

std::thread *

cliThread

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    if (cliThread)
    {
#ifdef _WIN32
        // First try to cancel any I/O in the CLI thread
        if (!CancelSynchronousIo(cliThread->native_handle()))
        {
            // if CancelSynchronousIo() fails, print the error and try with old way
            DWORD errorCode = GetLastError();
            LPCSTR errorBuffer;
 
            DWORD formatReturnCode = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS,
                nullptr, errorCode, 0, (LPTSTR)&errorBuffer, 0, nullptr);
            if (!formatReturnCode)
                errorBuffer = "Unknown error";
 
            LOG_DEBUG("server.worldserver", "Error cancelling I/O of CliThread, error code {}, detail: {}", uint32(errorCode), errorBuffer);
 
            if (!formatReturnCode)
                LocalFree((LPSTR)errorBuffer);
 
            // send keyboard input to safely unblock the CLI thread
            INPUT_RECORD b[4];
            HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
            b[0].EventType = KEY_EVENT;
            b[0].Event.KeyEvent.bKeyDown = TRUE;
            b[0].Event.KeyEvent.uChar.AsciiChar = 'X';
            b[0].Event.KeyEvent.wVirtualKeyCode = 'X';
            b[0].Event.KeyEvent.wRepeatCount = 1;
 
            b[1].EventType = KEY_EVENT;
            b[1].Event.KeyEvent.bKeyDown = FALSE;
            b[1].Event.KeyEvent.uChar.AsciiChar = 'X';
            b[1].Event.KeyEvent.wVirtualKeyCode = 'X';
            b[1].Event.KeyEvent.wRepeatCount = 1;
 
            b[2].EventType = KEY_EVENT;
            b[2].Event.KeyEvent.bKeyDown = TRUE;
            b[2].Event.KeyEvent.dwControlKeyState = 0;
            b[2].Event.KeyEvent.uChar.AsciiChar = '\r';
            b[2].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
            b[2].Event.KeyEvent.wRepeatCount = 1;
            b[2].Event.KeyEvent.wVirtualScanCode = 0x1c;
 
            b[3].EventType = KEY_EVENT;
            b[3].Event.KeyEvent.bKeyDown = FALSE;
            b[3].Event.KeyEvent.dwControlKeyState = 0;
            b[3].Event.KeyEvent.uChar.AsciiChar = '\r';
            b[3].Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
            b[3].Event.KeyEvent.wVirtualScanCode = 0x1c;
            b[3].Event.KeyEvent.wRepeatCount = 1;
            DWORD numb;
            WriteConsoleInput(hStdIn, b, 4, &numb);
        }
#endif
        cliThread->join();
        delete cliThread;
    }
}

References LOG_DEBUG.

Referenced by main().

SignalHandler()

void SignalHandler	(	boost::system::error_code const &	error,
		int	signalNumber
	)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    if (!error)
        World::StopNow(SHUTDOWN_EXIT_CODE);
}

References SHUTDOWN_EXIT_CODE, and World::StopNow().

Referenced by main().

Start()

static void FreezeDetector::Start ( std::shared_ptr< FreezeDetector > const &  freezeDetector )

inlinestatic

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

    {
        freezeDetector->_timer.expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(5));
        freezeDetector->_timer.async_wait(std::bind(&FreezeDetector::Handler, std::weak_ptr<FreezeDetector>(freezeDetector), std::placeholders::_1));
    }

References Acore::Asio::SteadyTimer::GetExpirationTime(), and FreezeDetector::Handler().

Referenced by main().

StartDB()

bool StartDB

(

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

Initialize connection to the databases.

• Get the realm Id from the configuration file

• Clean the database before starting. Cluster.Enabled is read from config here because sToCloud9Sidecar->Init() has not run yet; ClusterModeEnabled() would still be the default false.

• Insert version info into DB

{
    MySQL::Library_Init();
 
    // Load databases
    DatabaseLoader loader("server.worldserver", DatabaseLoader::DATABASE_MASK_ALL, AC_MODULES_LIST);
    loader
        .AddDatabase(LoginDatabase, "Login")
        .AddDatabase(CharacterDatabase, "Character")
        .AddDatabase(WorldDatabase, "World");
 
    if (!loader.Load())
        return false;
 
    if (!sScriptMgr->OnModuleDatabasesLoading())
        return false;
 
    realm.Id.Realm = sConfigMgr->GetOption<uint32>("RealmID", 1);
    if (!realm.Id.Realm)
    {
        LOG_ERROR("server.worldserver", "Realm ID not defined in configuration file");
        return false;
    }
    else if (realm.Id.Realm > 255)
    {
        /*
         * Due to the client only being able to read a realm.Id.Realm
         * with a size of uint8 we can "only" store up to 255 realms
         * anything further the client will behave anormaly
        */
        LOG_ERROR("server.worldserver", "Realm ID must range from 1 to 255");
        return false;
    }
 
    LOG_INFO("server.loading", "Loading World Information...");
    LOG_INFO("server.loading", "> RealmID:              {}", realm.Id.Realm);
 
    if (!sConfigMgr->GetOption<bool>("Cluster.Enabled", false))
        ClearOnlineAccounts();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_VERSION);
    stmt->SetData(0, GitRevision::GetFullVersion());
    stmt->SetData(1, GitRevision::GetHash());
    WorldDatabase.Execute(stmt);
 
    sWorld->LoadDBVersion();
 
    LOG_INFO("server.loading", "> Version DB world:     {}", sWorld->GetDBVersion());
 
    sScriptMgr->OnAfterDatabasesLoaded(loader.GetUpdateFlags());
 
    return true;
}

References DatabaseLoader::AddDatabase(), CharacterDatabase, ClearOnlineAccounts(), DatabaseLoader::DATABASE_MASK_ALL, GitRevision::GetFullVersion(), GitRevision::GetHash(), DatabaseLoader::GetUpdateFlags(), Realm::Id, MySQL::Library_Init(), DatabaseLoader::Load(), LOG_ERROR, LOG_INFO, LoginDatabase, realm, RealmHandle::Realm, sConfigMgr, PreparedStatementBase::SetData(), sScriptMgr, sWorld, WORLD_UPD_VERSION, and WorldDatabase.

Referenced by main().

StartRaSocketAcceptor()

AsyncAcceptor * StartRaSocketAcceptor

(

Acore::Asio::IoContext &

ioContext

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    uint16 raPort = uint16(sConfigMgr->GetOption<int32>("Ra.Port", 3443));
    std::string raListener = sConfigMgr->GetOption<std::string>("Ra.IP", "0.0.0.0");
 
    AsyncAcceptor* acceptor = new AsyncAcceptor(ioContext, raListener, raPort);
    if (!acceptor->Bind())
    {
        LOG_ERROR("server.worldserver", "Failed to bind RA socket acceptor");
        delete acceptor;
        return nullptr;
    }
 
    acceptor->AsyncAccept<RASession>();
    return acceptor;
}

References LOG_ERROR, and sConfigMgr.

Referenced by main().

StopDB()

void StopDB

(

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

{
    CharacterDatabase.Close();
    WorldDatabase.Close();
    LoginDatabase.Close();
 
    sScriptMgr->OnModuleDatabasesClosing();
 
    MySQL::Library_End();
}

References CharacterDatabase, MySQL::Library_End(), LoginDatabase, sScriptMgr, and WorldDatabase.

Referenced by main().

utf8print()

void utf8print	(	void *	,
		std::string_view	str
	)

#include <azerothcore-wotlk/src/server/apps/worldserver/CommandLine/CliRunnable.cpp>

{
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    fmt::print("{}", str);
#else
{
    fmt::print("{}", str);
    fflush(stdout);
}
#endif
}

Referenced by CliThread().

WorldUpdateLoop()

void WorldUpdateLoop

(

)

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

• While we have not World::m_stopEvent, update the world

{
    uint32 minUpdateDiff = uint32(sConfigMgr->GetOption<int32>("MinWorldUpdateTime", 1));
    uint32 realCurrTime = 0;
    uint32 realPrevTime = getMSTime();
 
    uint32 maxCoreStuckTime = uint32(sConfigMgr->GetOption<int32>("MaxCoreStuckTime", 60)) * 1000;
    uint32 halfMaxCoreStuckTime = maxCoreStuckTime / 2;
    if (!halfMaxCoreStuckTime)
        halfMaxCoreStuckTime = std::numeric_limits<uint32>::max();
 
    LoginDatabase.WarnAboutSyncQueries(true);
    CharacterDatabase.WarnAboutSyncQueries(true);
    WorldDatabase.WarnAboutSyncQueries(true);
 
    sScriptMgr->OnDatabaseWarnAboutSyncQueries(true);
 
    while (!World::IsStopped())
    {
        ++World::m_worldLoopCounter;
        realCurrTime = getMSTime();
 
        uint32 diff = getMSTimeDiff(realPrevTime, realCurrTime);
        if (diff < minUpdateDiff)
        {
            uint32 sleepTime = minUpdateDiff - diff;
            if (sleepTime >= halfMaxCoreStuckTime)
                LOG_ERROR("server.worldserver", "WorldUpdateLoop() waiting for {} ms with MaxCoreStuckTime set to {} ms", sleepTime, maxCoreStuckTime);
            // sleep until enough time passes that we can update all timers
            std::this_thread::sleep_for(Milliseconds(sleepTime));
            continue;
        }
 
        sWorld->Update(diff);
        realPrevTime = realCurrTime;
 
#ifdef _WIN32
        if (m_ServiceStatus == 0)
            World::StopNow(SHUTDOWN_EXIT_CODE);
 
        while (m_ServiceStatus == 2)
            Sleep(1000);
#endif
    }
 
    sScriptMgr->OnDatabaseWarnAboutSyncQueries(false);
 
    LoginDatabase.WarnAboutSyncQueries(false);
    CharacterDatabase.WarnAboutSyncQueries(false);
    WorldDatabase.WarnAboutSyncQueries(false);
}

References CharacterDatabase, getMSTime(), getMSTimeDiff(), World::IsStopped(), LOG_ERROR, LoginDatabase, m_ServiceStatus, World::m_worldLoopCounter, sConfigMgr, SHUTDOWN_EXIT_CODE, sScriptMgr, World::StopNow(), sWorld, and WorldDatabase.

Referenced by main().

Variable Documentation

_lastChangeMsTime

uint32 FreezeDetector::_lastChangeMsTime

private

_maxCoreStuckTimeInMs

uint32 FreezeDetector::_maxCoreStuckTimeInMs

private

_timer

boost::asio::steady_timer FreezeDetector::_timer

private

_worldLoopCounter

uint32 FreezeDetector::_worldLoopCounter

private

CLI_PREFIX

constexpr char CLI_PREFIX[] = "AC> "

staticconstexpr

#include <azerothcore-wotlk/src/server/apps/worldserver/CommandLine/CliRunnable.cpp>

Referenced by CliThread(), and PrintCliPrefix().

m_ServiceStatus

int m_ServiceStatus = -1

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

Referenced by main(), and WorldUpdateLoop().

serviceDescription

char serviceDescription[] = "AzerothCore World of Warcraft emulator world service"

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

serviceLongName

char serviceLongName[] = "AzerothCore world service"

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>

serviceName

char serviceName[] = "worldserver"

#include <azerothcore-wotlk/src/server/apps/worldserver/Main.cpp>