RealmList Class Reference

Storage object for the list of realms on the server. More...

#include "RealmList.h"

Public Types
typedef std::map< RealmHandle, Realm >	RealmMap

Public Member Functions
void	Initialize (Acore::Asio::IoContext &ioContext, uint32 updateInterval)
void	Close ()
RealmMap const &	GetRealms () const
Realm const *	GetRealm (RealmHandle const &id) const
RealmBuildInfo const *	GetBuildInfo (uint32 build) const

Static Public Member Functions
static RealmList *	Instance ()

Private Member Functions
	RealmList ()
	~RealmList ()=default
void	LoadBuildInfo ()
void	UpdateRealms (boost::system::error_code const &error)
void	UpdateRealm (RealmHandle const &id, uint32 build, std::string const &name, boost::asio::ip::address &&address, boost::asio::ip::address &&localAddr, boost::asio::ip::address &&localSubmask, uint16 port, uint8 icon, RealmFlags flag, uint8 timezone, AccountTypes allowedSecurityLevel, float population)

Private Attributes
std::vector< RealmBuildInfo >	_builds
RealmMap	_realms
uint32	_updateInterval {0}
std::unique_ptr< Acore::Asio::DeadlineTimer >	_updateTimer
std::unique_ptr< Acore::Asio::Resolver >	_resolver

Detailed Description

Storage object for the list of realms on the server.

Member Typedef Documentation

RealmMap

typedef std::map<RealmHandle, Realm> RealmList::RealmMap

Constructor & Destructor Documentation

RealmList()

RealmList::RealmList ( )

private

: _updateInterval(0) { }

~RealmList()

RealmList::~RealmList ( )

privatedefault

Member Function Documentation

Close()

void RealmList::Close

(

)

{
    _updateTimer->cancel();
}

References _updateTimer.

GetBuildInfo()

RealmBuildInfo const * RealmList::GetBuildInfo

(

uint32

build

)

const

{
    for (RealmBuildInfo const& clientBuild : _builds)
    {
        if (clientBuild.Build == build)
        {
            return &clientBuild;
        }
    }
 
    return nullptr;
}

References _builds.

GetRealm()

Realm const * RealmList::GetRealm

(

RealmHandle const &

id

)

const

{
    auto itr = _realms.find(id);
    if (itr != _realms.end())
    {
        return &itr->second;
    }
 
    return nullptr;
}

References _realms.

GetRealms()

RealmMap const & RealmList::GetRealms ( ) const

inline

{ return _realms; }

Initialize()

void RealmList::Initialize	(	Acore::Asio::IoContext &	ioContext,
		uint32	updateInterval
	)

{
    _updateInterval = updateInterval;
    _updateTimer = std::make_unique<Acore::Asio::DeadlineTimer>(ioContext);
    _resolver = std::make_unique<Acore::Asio::Resolver>(ioContext);
 
    LoadBuildInfo();
 
    // Get the content of the realmlist table in the database
    UpdateRealms(boost::system::error_code());
}

References _resolver, _updateInterval, _updateTimer, LoadBuildInfo(), and UpdateRealms().

Instance()

RealmList * RealmList::Instance ( )

static

{
    static RealmList instance;
    return &instance;
}

LoadBuildInfo()

void RealmList::LoadBuildInfo ( )

private

{
    //                                                              0             1              2              3      4                5                6
    if (auto result = LoginDatabase.Query("SELECT majorVersion, minorVersion, bugfixVersion, hotfixVersion, build, winChecksumSeed, macChecksumSeed FROM build_info ORDER BY build ASC"))
    {
        for (auto const& fields : *result)
        {
            RealmBuildInfo& build = _builds.emplace_back();
            build.MajorVersion = fields[0].Get<uint32>();
            build.MinorVersion = fields[1].Get<uint32>();
            build.BugfixVersion = fields[2].Get<uint32>();
            std::string hotfixVersion = fields[3].Get<std::string>();
 
            if (hotfixVersion.length() < build.HotfixVersion.size())
            {
                std::copy(hotfixVersion.begin(), hotfixVersion.end(), build.HotfixVersion.begin());
            }
            else
            {
                std::fill(hotfixVersion.begin(), hotfixVersion.end(), '\0');
            }
 
            build.Build = fields[4].Get<uint32>();
            std::string windowsHash = fields[5].Get<std::string>();
 
            if (windowsHash.length() == build.WindowsHash.size() * 2)
            {
                HexStrToByteArray(windowsHash, build.WindowsHash);
            }
 
            std::string macHash = fields[6].Get<std::string>();
 
            if (macHash.length() == build.MacHash.size() * 2)
            {
                HexStrToByteArray(macHash, build.MacHash);
            }
        }
    }
}

References _builds, RealmBuildInfo::BugfixVersion, RealmBuildInfo::Build, HexStrToByteArray(), RealmBuildInfo::HotfixVersion, LoginDatabase, RealmBuildInfo::MacHash, RealmBuildInfo::MajorVersion, RealmBuildInfo::MinorVersion, and RealmBuildInfo::WindowsHash.

Referenced by Initialize().

UpdateRealm()

void RealmList::UpdateRealm ( RealmHandle const &  id, uint32  build, std::string const &  name, boost::asio::ip::address &&  address, boost::asio::ip::address &&  localAddr, boost::asio::ip::address &&  localSubmask, uint16  port, uint8  icon, RealmFlags  flag, uint8  timezone, AccountTypes  allowedSecurityLevel, float  population  )

private

{
    // Create new if not exist or update existed
    Realm& realm = _realms[id];
 
    realm.Id = id;
    realm.Build = build;
    realm.Name = name;
    realm.Type = icon;
    realm.Flags = flag;
    realm.Timezone = timezone;
    realm.AllowedSecurityLevel = allowedSecurityLevel;
    realm.PopulationLevel = population;
 
    if (!realm.ExternalAddress || *realm.ExternalAddress != address)
    {
        realm.ExternalAddress = std::make_unique<boost::asio::ip::address>(std::move(address));
    }
 
    if (!realm.LocalAddress || *realm.LocalAddress != localAddr)
    {
        realm.LocalAddress = std::make_unique<boost::asio::ip::address>(std::move(localAddr));
    }
 
    if (!realm.LocalSubnetMask || *realm.LocalSubnetMask != localSubmask)
    {
        realm.LocalSubnetMask = std::make_unique<boost::asio::ip::address>(std::move(localSubmask));
    }
 
    realm.Port = port;
}

References _realms, Realm::AllowedSecurityLevel, Realm::Build, Realm::ExternalAddress, Realm::Flags, Realm::Id, Realm::LocalAddress, Realm::LocalSubnetMask, Realm::Name, Realm::PopulationLevel, Realm::Port, realm, Realm::Timezone, and Realm::Type.

Referenced by UpdateRealms().

UpdateRealms()

void RealmList::UpdateRealms ( boost::system::error_code const &  error )

private

{
    if (error)
    {
        // Skip update if have errors
        return;
    }
 
    LOG_DEBUG("server.authserver", "Updating Realm List...");
 
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    std::map<RealmHandle, std::string> existingRealms;
    for (auto const& [handle, realm] : _realms)
    {
        existingRealms[handle] = realm.Name;
    }
 
    _realms.clear();
 
    // Circle through results and add them to the realm map
    if (result)
    {
        for (auto const& fields : *result)
        {
            try
            {
                uint32 realmId = fields[0].Get<uint32>();
                std::string name = fields[1].Get<std::string>();
                std::string externalAddressString = fields[2].Get<std::string>();
                std::string localAddressString = fields[3].Get<std::string>();
                std::string localSubmaskString = fields[4].Get<std::string>();
                uint16 port = fields[5].Get<uint16>();
 
                Optional<boost::asio::ip::tcp::endpoint> externalAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), externalAddressString, "");
                if (!externalAddress)
                {
                    LOG_ERROR("server.authserver", "Could not resolve address {} for realm \"{}\" id {}", externalAddressString, name, realmId);
                    continue;
                }
 
                Optional<boost::asio::ip::tcp::endpoint> localAddress = _resolver->Resolve(boost::asio::ip::tcp::v4(), localAddressString, "");
                if (!localAddress)
                {
                    LOG_ERROR("server.authserver", "Could not resolve localAddress {} for realm \"{}\" id {}", localAddressString, name, realmId);
                    continue;
                }
 
                Optional<boost::asio::ip::tcp::endpoint> localSubmask = _resolver->Resolve(boost::asio::ip::tcp::v4(), localSubmaskString, "");
                if (!localSubmask)
                {
                    LOG_ERROR("server.authserver", "Could not resolve localSubnetMask {} for realm \"{}\" id {}", localSubmaskString, name, realmId);
                    continue;
                }
 
                uint8 icon = fields[6].Get<uint8>();
 
                if (icon == REALM_TYPE_FFA_PVP)
                {
                    icon = REALM_TYPE_PVP;
                }
 
                if (icon >= MAX_CLIENT_REALM_TYPE)
                {
                    icon = REALM_TYPE_NORMAL;
                }
 
                RealmFlags flag = RealmFlags(fields[7].Get<uint8>());
                uint8 timezone = fields[8].Get<uint8>();
                uint8 allowedSecurityLevel = fields[9].Get<uint8>();
                float pop = fields[10].Get<float>();
                uint32 build = fields[11].Get<uint32>();
 
                RealmHandle id{ realmId };
 
                UpdateRealm(id, build, name, externalAddress->address(), localAddress->address(), localSubmask->address(), port, icon, flag,
                    timezone, (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), pop);
 
                if (!existingRealms.count(id))
                {
                    LOG_INFO("server.authserver", "Added realm \"{}\" at {}:{}.", name, externalAddressString, port);
                }
                else
                {
                    LOG_DEBUG("server.authserver", "Updating realm \"{}\" at {}:{}.", name, externalAddressString, port);
                }
 
                existingRealms.erase(id);
            }
            catch (std::exception const& ex)
            {
                LOG_ERROR("server.authserver", "Realmlist::UpdateRealms has thrown an exception: {}", ex.what());
                ABORT();
            }
        }
    }
 
    for (auto itr = existingRealms.begin(); itr != existingRealms.end(); ++itr)
        LOG_INFO("server.authserver", "Removed realm \"{}\".", itr->second);
 
    if (_updateInterval)
    {
        _updateTimer->expires_from_now(boost::posix_time::seconds(_updateInterval));
        _updateTimer->async_wait(std::bind(&RealmList::UpdateRealms, this, std::placeholders::_1));
    }
}

References _realms, _resolver, _updateInterval, _updateTimer, ABORT, LOG_DEBUG, LOG_ERROR, LOG_INFO, LOGIN_SEL_REALMLIST, LoginDatabase, MAX_CLIENT_REALM_TYPE, Realm::Name, realm, REALM_TYPE_FFA_PVP, REALM_TYPE_NORMAL, REALM_TYPE_PVP, SEC_ADMINISTRATOR, UpdateRealm(), and UpdateRealms().

Referenced by Initialize(), and UpdateRealms().

Member Data Documentation

_builds

std::vector<RealmBuildInfo> RealmList::_builds

private

Referenced by GetBuildInfo(), and LoadBuildInfo().

_realms

RealmMap RealmList::_realms

private

Referenced by GetRealm(), UpdateRealm(), and UpdateRealms().

_resolver

std::unique_ptr<Acore::Asio::Resolver> RealmList::_resolver

private

Referenced by Initialize(), and UpdateRealms().

_updateInterval

uint32 RealmList::_updateInterval {0}

private

Referenced by Initialize(), and UpdateRealms().

_updateTimer

std::unique_ptr<Acore::Asio::DeadlineTimer> RealmList::_updateTimer

private

Referenced by Close(), Initialize(), and UpdateRealms().