ToCloud9Sidecar Class Reference

#include "TC9Sidecar.h"

Public Member Functions
bool	CheckLibsidecarAbi ()
void	Init (uint16 port, int realmId)
void	Deinit ()
bool	ClusterModeEnabled ()
bool	IsCrossrealm ()
bool	IsMapAssigned (uint32 mapId)
void	SetupHooks ()
void	SetupGrpcHandlers ()
void	ProcessHooks ()
void	ProcessGrpcOrHttpRequests ()
void	ProcessAsyncTasks ()
uint32	GenerateCharacterGuid (uint16 realmId=DEFAULT_NON_CROSSREALM_REALM_ID)
uint32	GenerateItemGuid (uint16 realmId=DEFAULT_NON_CROSSREALM_REALM_ID)
uint32	GenerateInstanceGuid (uint16 realmId=DEFAULT_NON_CROSSREALM_REALM_ID)
void	OnPlayerLeftBattleground (uint64 playerGUID, uint32 realmID, uint32 instanceID)
void	OnBattlegroundStatusChanged (uint32 instanceID, uint8 status)
bool	NatsPublish (std::string const &subject, std::string const &payload)
bool	NatsSubscribe (std::string const &subject, void(*handler)(char const *subject, char const *payload, int payloadLen))

Static Public Member Functions
static ToCloud9Sidecar *	instance ()

Private Member Functions
	ToCloud9Sidecar ()
	~ToCloud9Sidecar ()

Static Private Member Functions
static void	OnMapsReassigned (uint32 *addedMaps, int addedMapsSize, uint32 *removedMaps, int removedMapsSize)

Private Attributes
bool	_clusterModeEnabled
bool	_isCrossrealm
bool	_assignedMapsByID [MAX_MAP_ID]
AsyncCallbackProcessor< AsyncTask< bool > >	_asyncTasksProcessor

Detailed Description

Constructor & Destructor Documentation

ToCloud9Sidecar()

ToCloud9Sidecar::ToCloud9Sidecar ( )

private

                                 : _clusterModeEnabled(false), _isCrossrealm(false)
{
}

~ToCloud9Sidecar()

ToCloud9Sidecar::~ToCloud9Sidecar ( )

inlineprivate

{};

Member Function Documentation

CheckLibsidecarAbi()

bool ToCloud9Sidecar::CheckLibsidecarAbi

(

)

When Cluster.Enabled, validate libsidecar (real library required; ABI match). Call after config and logging are ready, before DB/network startup.

Returns

false if worldserver should exit with code 1.

{
    if (!sConfigMgr->GetOption<bool>("Cluster.Enabled", false))
        return true;
 
    int libMajor = 0;
    int libMinor = 0;
    int libPatch = 0;
    TC9GetVersion(&libMajor, &libMinor, &libPatch);
    char const* libVersionStr = TC9GetVersionString();
 
#if defined(TC9_LIBSIDECAR_IS_STUB)
    char const* libKind = "stub";
#else
    char const* libKind = "shared library";
#endif
 
#if defined(TC9_LIBSIDECAR_IS_STUB)
    // Stub always "matches" its own macros; fail here instead of after the realm
    // is online when TC9InitLib panics.
    // SetSynchronous first: this runs before the io_context pool starts, so async
    // LOG_* would never print on early return. Success path leaves async alone.
    sLog->SetSynchronous();
    LOG_INFO("server", "libsidecar ({}) runtime {}.{}.{} ({}) - headers {}.{}.{} ({})",
        libKind,
        libMajor, libMinor, libPatch,
        libVersionStr ? libVersionStr : "?",
        TC9_VERSION_MAJOR, TC9_VERSION_MINOR, TC9_VERSION_PATCH,
        TC9_VERSION_STRING);
    LOG_ERROR("server",
        "Cluster.Enabled requires the real libsidecar shared library. "
        "This worldserver was built with the stub (default). "
        "Rebuild with -DUSE_REAL_LIBSIDECAR=ON and place matching headers + library "
        "from the same libsidecar release under deps/libsidecar.");
    return false;
#else
    if (TC9CheckAbiCompatible(TC9_VERSION_MAJOR, TC9_VERSION_MINOR) != 0)
    {
        sLog->SetSynchronous();
        LOG_INFO("server", "libsidecar ({}) runtime {}.{}.{} ({}) - headers {}.{}.{} ({})",
            libKind,
            libMajor, libMinor, libPatch,
            libVersionStr ? libVersionStr : "?",
            TC9_VERSION_MAJOR, TC9_VERSION_MINOR, TC9_VERSION_PATCH,
            TC9_VERSION_STRING);
        LOG_ERROR("server",
            "libsidecar ABI mismatch: worldserver was built for {}.{}.{} (headers {}), "
            "but loaded library is {}.{}.{} ({}). "
            "Copy matching headers + library from the same libsidecar build/release.",
            TC9_VERSION_MAJOR, TC9_VERSION_MINOR, TC9_VERSION_PATCH, TC9_VERSION_STRING,
            libMajor, libMinor, libPatch,
            libVersionStr ? libVersionStr : "?");
        return false;
    }
 
    LOG_INFO("server", "libsidecar ({}) runtime {}.{}.{} ({}) - headers {}.{}.{} ({})",
        libKind,
        libMajor, libMinor, libPatch,
        libVersionStr ? libVersionStr : "?",
        TC9_VERSION_MAJOR, TC9_VERSION_MINOR, TC9_VERSION_PATCH,
        TC9_VERSION_STRING);
    return true;
#endif
}

References LOG_ERROR, LOG_INFO, sConfigMgr, and sLog.

ClusterModeEnabled()

bool ToCloud9Sidecar::ClusterModeEnabled ( )

inline

{ return _clusterModeEnabled; }

References _clusterModeEnabled.

Deinit()

void ToCloud9Sidecar::Deinit

(

)

{
    if (_clusterModeEnabled)
        TC9GracefulShutdown();
}

References _clusterModeEnabled.

GenerateCharacterGuid()

uint32 ToCloud9Sidecar::GenerateCharacterGuid

(

uint16

realmId = DEFAULT_NON_CROSSREALM_REALM_ID

)

{
    return uint32(TC9GetNextAvailableCharacterGuid(realmId));
}

GenerateInstanceGuid()

uint32 ToCloud9Sidecar::GenerateInstanceGuid

(

uint16

realmId = DEFAULT_NON_CROSSREALM_REALM_ID

)

{
    return uint32(TC9GetNextAvailableInstanceGuid(realmId));
}

GenerateItemGuid()

uint32 ToCloud9Sidecar::GenerateItemGuid

(

uint16

realmId = DEFAULT_NON_CROSSREALM_REALM_ID

)

{
    return uint32(TC9GetNextAvailableItemGuid(realmId));
}

Init()

void ToCloud9Sidecar::Init	(	uint16	port,
		int	realmId
	)

{
    _clusterModeEnabled = sConfigMgr->GetOption<bool>("Cluster.Enabled", false);
 
    if (_clusterModeEnabled)
    {
        uint32 *assignedMaps;
        int assignedMapsSize = 0;
 
        _isCrossrealm = sConfigMgr->GetOption<bool>("Cluster.IsCrossrealm", false);
 
        std::string availableMaps = sConfigMgr->GetOption<std::string>("Cluster.AvailableMaps", AVAILABLE_MAPS_ALL_MAPS);
        TC9InitLib(port, realmId, _isCrossrealm, availableMaps.data(), &assignedMaps, &assignedMapsSize);
 
        for (int i = 0; i < MAX_MAP_ID; i++)
            _assignedMapsByID[i] = false;
 
        for (int i = 0; i < assignedMapsSize; i++)
        {
            uint32 mapId = assignedMaps[i];
            if (mapId >= MAX_MAP_ID)
            {
                LOG_ERROR("server", "ToCloud9Sidecar::Init: map id {} out of range [0, {}), ignored",
                    mapId, MAX_MAP_ID);
                continue;
            }
            _assignedMapsByID[mapId] = true;
        }
 
        if (assignedMapsSize > 0)
            free(assignedMaps);
 
        SetupHooks();
        SetupGrpcHandlers();
    }
}

References _assignedMapsByID, _clusterModeEnabled, _isCrossrealm, AVAILABLE_MAPS_ALL_MAPS, LOG_ERROR, MAX_MAP_ID, sConfigMgr, SetupGrpcHandlers(), and SetupHooks().

instance()

ToCloud9Sidecar * ToCloud9Sidecar::instance ( )

static

{
    static ToCloud9Sidecar instance;
    return &instance;
}

References instance().

Referenced by instance().

IsCrossrealm()

bool ToCloud9Sidecar::IsCrossrealm ( )

inline

{ return _isCrossrealm; }

References _isCrossrealm.

IsMapAssigned()

bool ToCloud9Sidecar::IsMapAssigned

(

uint32

mapId

)

{
    if (mapId >= MAX_MAP_ID)
        return false;
 
    return _assignedMapsByID[mapId];
}

References _assignedMapsByID, and MAX_MAP_ID.

NatsPublish()

bool ToCloud9Sidecar::NatsPublish	(	std::string const &	subject,
		std::string const &	payload
	)

{
    if (!_clusterModeEnabled)
        return false;
 
    if (payload.size() > size_t(std::numeric_limits<int>::max()))
        return false;
 
    return TC9NatsPublish(subject.c_str(), payload.c_str(), int(payload.size())) == 0;
}

References _clusterModeEnabled.

NatsSubscribe()

bool ToCloud9Sidecar::NatsSubscribe	(	std::string const &	subject,
		void(*)(char const *subject, char const *payload, int payloadLen)	handler
	)

{
    if (!_clusterModeEnabled || !handler)
        return false;
 
    return TC9NatsSubscribe(subject.c_str(), handler) == 0;
}

References _clusterModeEnabled.

OnBattlegroundStatusChanged()

void ToCloud9Sidecar::OnBattlegroundStatusChanged	(	uint32	instanceID,
		uint8	status
	)

{
    TC9BattlegroundStatusChanged(instanceID, status);
}

OnMapsReassigned()

void ToCloud9Sidecar::OnMapsReassigned ( uint32 *  addedMaps, int  addedMapsSize, uint32 *  removedMaps, int  removedMapsSize  )

staticprivate

{
    std::vector<uint32_t> newMapIDs;
    newMapIDs.reserve(addedMapsSize > 0 ? addedMapsSize : 0);
 
    for (int i = 0; i < addedMapsSize; i++)
    {
        uint32 mapId = addedMaps[i];
        if (mapId >= MAX_MAP_ID)
        {
            LOG_ERROR("server", "ToCloud9Sidecar::OnMapsReassigned: added map id {} out of range [0, {}), ignored",
                mapId, MAX_MAP_ID);
            continue;
        }
 
        sToCloud9Sidecar->_assignedMapsByID[mapId] = true;
        newMapIDs.push_back(mapId);
 
        if (Map* map = sMapMgr->FindBaseNonInstanceMap(mapId))
            map->StopPlayersRedirectKickTimer();
    }
 
    for (int i = 0; i < removedMapsSize; i++)
    {
        uint32 mapId = removedMaps[i];
        if (mapId >= MAX_MAP_ID)
        {
            LOG_ERROR("server", "ToCloud9Sidecar::OnMapsReassigned: removed map id {} out of range [0, {}), ignored",
                mapId, MAX_MAP_ID);
            continue;
        }
 
        sToCloud9Sidecar->_assignedMapsByID[mapId] = false;
 
        if (Map* map = sMapMgr->FindBaseNonInstanceMap(mapId))
            map->StartPlayersRedirectKickTimer();
    }
 
    if (!newMapIDs.empty())
    {
        auto loadRowsPtr = std::make_shared<InstanceMapLoadRows>();
 
        AsyncTask<bool> task(
           [loadRowsPtr, newMapIDs]() -> bool {
               LOG_INFO("server", "Starting to load data for newly assigned maps...");
 
               *loadRowsPtr = sInstanceSaveMgr->LoadInstanceSavesAndBindsForMapIDs(newMapIDs);
               return true;
           },
           [loadRowsPtr, newMapIDs](bool) {
               sInstanceSaveMgr->MergeWithNewInstanceSaves(*loadRowsPtr);
               TC9ReadyToAcceptPlayersFromMaps((uint32_t*)newMapIDs.data(), newMapIDs.size());
 
               LOG_INFO("server", "Finished loading data for newly assigned maps.");
           }
        );
 
        task.ExecuteAsync();
        sToCloud9Sidecar->_asyncTasksProcessor.AddCallback(std::move(task));
    }
}

References AsyncTask< T >::ExecuteAsync(), LOG_ERROR, LOG_INFO, MAX_MAP_ID, sInstanceSaveMgr, sMapMgr, and sToCloud9Sidecar.

Referenced by SetupHooks().

OnPlayerLeftBattleground()

void ToCloud9Sidecar::OnPlayerLeftBattleground	(	uint64	playerGUID,
		uint32	realmID,
		uint32	instanceID
	)

{
    TC9PlayerLeftBattleground(playerGUID, realmID, instanceID);
}

ProcessAsyncTasks()

void ToCloud9Sidecar::ProcessAsyncTasks

(

)

{
    _asyncTasksProcessor.ProcessReadyCallbacks();
}

References _asyncTasksProcessor, and AsyncCallbackProcessor< T >::ProcessReadyCallbacks().

ProcessGrpcOrHttpRequests()

void ToCloud9Sidecar::ProcessGrpcOrHttpRequests

(

)

{
    TC9ProcessGRPCOrHTTPRequests();
}

ProcessHooks()

void ToCloud9Sidecar::ProcessHooks

(

)

{
    TC9ProcessEventsHooks();
}

SetupGrpcHandlers()

void ToCloud9Sidecar::SetupGrpcHandlers

(

)

{
    TC9SetGetPlayerItemsByGuidsHandler(&ToCloud9GrpcHandler::GetPlayerItemsByGuids);
    TC9SetRemoveItemsWithGuidsFromPlayerHandler(&ToCloud9GrpcHandler::RemoveItemsWithGuidsFromPlayer);
    TC9SetAddExistingItemToPlayerHandler(&ToCloud9GrpcHandler::AddExistingItemToPlayer);
 
    TC9SetGetMoneyForPlayerHandler(&ToCloud9GrpcHandler::GetMoneyForPlayer);
    TC9SetModifyMoneyForPlayerHandler(&ToCloud9GrpcHandler::ModifyMoneyForPlayer);
 
    TC9SetCanPlayerInteractWithGOAndTypeHandler(&ToCloud9GrpcHandler::CanPlayerInteractWithGOAndType);
    TC9SetCanPlayerInteractWithNPCAndFlagsHandler(&ToCloud9GrpcHandler::CanPlayerInteractWithNPCAndFlags);
 
    TC9SetBattlegroundStartHandler(&ToCloud9GrpcHandler::StartBattleground);
    TC9SetBattlegroundAddPlayersHandler(&ToCloud9GrpcHandler::AddPlayersToBattleground);
    TC9SetCanPlayerJoinBattlegroundQueueHandler(&ToCloud9GrpcHandler::CanPlayerJoinBattlegroundQueue);
    TC9SetCanPlayerTeleportToBattlegroundHandler(&ToCloud9GrpcHandler::CanPlayerTeleportToBattleground);
 
    TC9SetMonitoringDataCollectorHandler(&HandleMonitoringRequest);
}

References ToCloud9GrpcHandler::AddExistingItemToPlayer(), ToCloud9GrpcHandler::AddPlayersToBattleground(), ToCloud9GrpcHandler::CanPlayerInteractWithGOAndType(), ToCloud9GrpcHandler::CanPlayerInteractWithNPCAndFlags(), ToCloud9GrpcHandler::CanPlayerJoinBattlegroundQueue(), ToCloud9GrpcHandler::CanPlayerTeleportToBattleground(), ToCloud9GrpcHandler::GetMoneyForPlayer(), ToCloud9GrpcHandler::GetPlayerItemsByGuids(), HandleMonitoringRequest(), ToCloud9GrpcHandler::ModifyMoneyForPlayer(), ToCloud9GrpcHandler::RemoveItemsWithGuidsFromPlayer(), and ToCloud9GrpcHandler::StartBattleground().

Referenced by Init().

SetupHooks()

void ToCloud9Sidecar::SetupHooks

(

)

{
    TC9SetOnMapsReassignedHook(&ToCloud9Sidecar::OnMapsReassigned);
 
    TC9SetOnGuildMemberLeftHook(&ToCloud9GuildHooks::OnGuildMemberLeft);
    TC9SetOnGuildMemberAddedHook(&ToCloud9GuildHooks::OnGuildMemberAdded);
    TC9SetOnGuildMemberRemovedHook(&ToCloud9GuildHooks::OnGuildMemberRemoved);
 
    TC9SetOnGroupCreatedHook(&ToCloud9GroupHooks::OnGroupCreated);
    TC9SetOnGroupDisbandedHook(&ToCloud9GroupHooks::OnGroupDisbanded);
    TC9SetOnGroupMemberAddedHook(&ToCloud9GroupHooks::OnGroupMemberAdded);
    TC9SetOnGroupMemberRemovedHook(&ToCloud9GroupHooks::OnGroupMemberRemoved);
    TC9SetOnGroupLootTypeChangedHook(&ToCloud9GroupHooks::OnGroupLootTypeChanged);
    TC9SetOnGroupConvertedToRaidHook(&ToCloud9GroupHooks::OnGroupConvertedToRaid);
    TC9SetOnGroupRaidDifficultyChangedHook(&ToCloud9GroupHooks::OnGroupRaidDifficultyChanged);
    TC9SetOnGroupDungeonDifficultyChangedHook(&ToCloud9GroupHooks::OnGroupDungeonDifficultyChanged);
}

References ToCloud9GroupHooks::OnGroupConvertedToRaid(), ToCloud9GroupHooks::OnGroupCreated(), ToCloud9GroupHooks::OnGroupDisbanded(), ToCloud9GroupHooks::OnGroupDungeonDifficultyChanged(), ToCloud9GroupHooks::OnGroupLootTypeChanged(), ToCloud9GroupHooks::OnGroupMemberAdded(), ToCloud9GroupHooks::OnGroupMemberRemoved(), ToCloud9GroupHooks::OnGroupRaidDifficultyChanged(), ToCloud9GuildHooks::OnGuildMemberAdded(), ToCloud9GuildHooks::OnGuildMemberLeft(), ToCloud9GuildHooks::OnGuildMemberRemoved(), and OnMapsReassigned().

Referenced by Init().

Member Data Documentation

_assignedMapsByID

bool ToCloud9Sidecar::_assignedMapsByID[MAX_MAP_ID]

private

Referenced by Init(), and IsMapAssigned().

_asyncTasksProcessor

AsyncCallbackProcessor<AsyncTask<bool> > ToCloud9Sidecar::_asyncTasksProcessor

private

Referenced by ProcessAsyncTasks().

_clusterModeEnabled

bool ToCloud9Sidecar::_clusterModeEnabled

private

Referenced by ClusterModeEnabled(), Deinit(), Init(), NatsPublish(), and NatsSubscribe().

_isCrossrealm

bool ToCloud9Sidecar::_isCrossrealm

private

Referenced by Init(), and IsCrossrealm().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/TC9Sidecar/TC9Sidecar.h
• azerothcore-wotlk/src/server/game/TC9Sidecar/TC9Sidecar.cpp