swg-source/src
1
0
Fork 0
mirror of https://github.com/SWG-Source/src.git synced 2026-07-29 23:15:56 -04:00
Code Issues Projects Releases Wiki Activity

let's see how many typos i have

Browse Source
This commit is contained in:
DarthArgus
2016-09-30 19:57:14 -05:00
parent a67734af5f
commit 109d4234c9
15 changed files with 2505 additions and 2294 deletions
Download Patch File Download Diff File Expand all files Collapse all files
engine/server/application/ServerConsole/src/shared/ServerConsoleConnection.cpp
+16 -8
View File
@@ -10,6 +10,8 @@
#include "sharedNetwork/NetworkSetupData.h"
#include "sharedNetworkMessages/ConsoleChannelMessages.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
ServerConsoleConnection::ServerConsoleConnection(const std::string & address, const unsigned short port) :
@@ -44,15 +46,21 @@ void ServerConsoleConnection::onReceive(const Archive::ByteStream & bs)
Archive::ReadIterator ri = bs.begin();
GameNetworkMessage m(ri);
ri = bs.begin();
const uint32 messageType = m.getType();
if(m.isType("ConGenericMessage"))
{
ConGenericMessage msg(ri);
fprintf(stdout, "%s", msg.getMsg().c_str());
}
else if(m.isType("RequestDisconnect"))
{
disconnect();
switch(messageType) {
case constcrc("ConGenericMessage") :
{
ConGenericMessage msg(ri);
fprintf(stdout, "%s", msg.getMsg().c_str());
break;
}
case constcrc("RequestDisconnect") :
{
disconnect();
break;
}
}
}
engine/server/application/StationPlayersCollector/src/shared/CentralServerConnection.cpp
+8 -9
View File
@@ -17,6 +17,8 @@
#include "sharedNetwork/NetworkSetupData.h"
#include "UnicodeUtils.h"
#include "sharedFoundation/CrcConstexpr.hpp"
// ======================================================================
namespace CentralServerConnectionNamespace
@@ -84,19 +86,16 @@ void CentralServerConnection::onReceive(const Archive::ByteStream & message)
GameNetworkMessage msg(ri);
ri = message.begin();
if (msg.isType("SPCharacterProfileMessage"))
if (msg.getType() == constcrc("SPCharacterProfileMessage"))
{
DEBUG_REPORT_LOG(true,(" Got SPCharacterProfileMessage:"));
StationPlayersCollector::handleSPCharacterProfileData(msg);
}
else if ( msg.isType("SomeOtherMessage") )
{
DEBUG_REPORT_LOG(true,(" Got SPCharacterProfileMessage:"));
StationPlayersCollector::handleSPCharacterProfileData(msg);
}
// else if ( msg.isType("SomeOtherMessage") ) {} leaving this here just so i can ask, what the fuck sony?
else
{
DEBUG_REPORT_LOG(true, ("Got (%s) handing off to ServerConnection::onReceive\n", msg.getCmdName().c_str()));
ServerConnection::onReceive(message);
DEBUG_REPORT_LOG(true, ("Got (%s) handing off to ServerConnection::onReceive\n", msg.getCmdName().c_str()));
ServerConnection::onReceive(message);
}
}
engine/server/application/TaskManager/src/shared/CentralConnection.cpp
+28 -19
View File
@@ -14,6 +14,8 @@
#include "sharedFoundation/Clock.h"
#include "sharedMessageDispatch/Transceiver.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
CentralConnection::CentralConnection(TaskConnection * c, const std::string & n) :
@@ -84,30 +86,37 @@ void CentralConnection::receive(const Archive::ByteStream & message)
{
Archive::ReadIterator r(message);
GameNetworkMessage m(r);
r = message.begin();
if(m.isType("TaskSpawnProcess"))
{
TaskSpawnProcess s(r);
IGNORE_RETURN(TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()));
}
else if(m.isType("PreloadFinishedMessage"))
{
PreloadFinishedMessage m(r);
if (m.getFinished())
TaskManager::onPreloadFinished();
}
else if(m.isType("ConGenericMessage"))
{
ConGenericMessage taskConsoleCommand(r);
const uint32 messageType = m.getType();
static std::string command = taskConsoleCommand.getMsg();
while(command.rfind(' ') != command.npos || command.rfind('\n') != command.npos || command.rfind('\r') != command.npos)
switch (messageType) {
case constcrc("TaskSpawnProcess") :
{
command = command.substr(0, command.length() - 1);
TaskSpawnProcess s(r);
IGNORE_RETURN(TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()));
break;
}
case constcrc("PreloadFinishedMessage") :
{
PreloadFinishedMessage m(r);
if (m.getFinished())
TaskManager::onPreloadFinished();
break;
}
case constcrc("ConGenericMessage") :
{
ConGenericMessage taskConsoleCommand(r);
TaskManager::executeCommand(command);
static std::string command = taskConsoleCommand.getMsg();
while(command.rfind(' ') != command.npos || command.rfind('\n') != command.npos || command.rfind('\r') != command.npos)
{
command = command.substr(0, command.length() - 1);
}
TaskManager::executeCommand(command);
break;
}
}
}
engine/server/application/TaskManager/src/shared/DatabaseConnection.cpp
+18 -10
View File
@@ -10,6 +10,8 @@
#include "serverNetworkMessages/GameTaskManagerMessages.h"
#include "serverNetworkMessages/TaskSpawnProcess.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
DatabaseConnection::DatabaseConnection() :
@@ -42,17 +44,23 @@ void DatabaseConnection::receive(const Archive::ByteStream & message)
{
Archive::ReadIterator r(message);
GameNetworkMessage m(r);
r = message.begin();
if(m.isType("TaskSpawnProcess"))
{
TaskSpawnProcess s(r);
IGNORE_RETURN(TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()));
}
else if(m.isType("ServerIdleMessage"))
{
ServerIdleMessage msg(r);
TaskManager::onDatabaseIdle(msg.getIsIdle());
const uint32 messageType = m.getType();
switch(messageType) {
case constcrc("TaskSpawnProcess") :
{
TaskSpawnProcess s(r);
IGNORE_RETURN(TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()));
break;
}
case constcrc("ServerIdleMessage") :
{
ServerIdleMessage msg(r);
TaskManager::onDatabaseIdle(msg.getIsIdle());
break;
}
}
}
engine/server/application/TaskManager/src/shared/ManagerConnection.cpp
+112 -99
View File
@@ -24,6 +24,8 @@
#include "TaskConnection.h"
#include "TaskManager.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
namespace ManagerConnectionNamespace
@@ -94,115 +96,126 @@ void ManagerConnection::onReceive(const Archive::ByteStream & message)
{
Archive::ReadIterator r(message);
GameNetworkMessage m(r);
r = message.begin();
if (m.isType("SystemTimeCheck"))
{
long const currentTime = static_cast<long>(::time(nullptr));
GenericValueTypeMessage<std::pair<std::string, long > > msg(r);
if (TaskManager::getNodeLabel() == "node0")
const uint32 messageType = m.getType();
switch(messageType) {
case constcrc("SystemTimeCheck") :
{
if ((std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second)) > ConfigTaskManager::getMaximumClockDriftToleranceSeconds())
long const currentTime = static_cast<long>(::time(nullptr));
GenericValueTypeMessage<std::pair<std::string, long > > msg(r);
if (TaskManager::getNodeLabel() == "node0")
{
LOG("CustomerService", ("system_clock_mismatch:System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld)", (std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second)), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, msg.getValue().first.c_str(), getRemoteAddress().c_str(), msg.getValue().second));
// tell CentralServer about the system clock mismatch so it can report an alert to SOEMon
GenericValueTypeMessage<std::string> systemTimeMismatchMessage("SystemTimeMismatchNotification",
FormattedString<1024>().sprintf("%s: %s (%s) is off by %ld seconds", CalendarTime::convertEpochToTimeStringLocal(static_cast<time_t>(currentTime)).c_str(), msg.getValue().first.c_str(), getRemoteAddress().c_str(), (std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second))));
TaskManager::sendToCentralServer(systemTimeMismatchMessage);
}
}
}
else if (m.isType("TaskConnectionIdMessage"))
{
static long const clockDriftFatalTimePeriod = static_cast<long>(TaskManager::getStartTime()) + ConfigTaskManager::getClockDriftFatalIntervalSeconds();
long const currentTime = static_cast<long>(::time(nullptr));
TaskConnectionIdMessage t(r);
WARNING_STRICT_FATAL(t.getServerType() != TaskConnectionIdMessage::TaskManager,
("ManagerConnection received wrong type identifier"));
WARNING_STRICT_FATAL(m_nodeLabel, ("Received new taskconnectionIdMessage with an already named connection"));
FATAL((ConfigTaskManager::getVerifyClusterName() && (TaskManager::getNodeLabel() == "node0") && (t.getServerType() == TaskConnectionIdMessage::TaskManager) && (t.getClusterName() != std::string(ConfigTaskManager::getClusterName()))), ("Remote TaskManager %s (%s) reported cluster name (%s) that is different from my cluster name (%s)", t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getClusterName().c_str(), ConfigTaskManager::getClusterName()));
// don't allow cluster to start if the system clock across the boxes are out of sync
bool remoteSystemClockInSync = true;
if (TaskManager::getNodeLabel() == "node0")
{
if ((std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())) > ConfigTaskManager::getMaximumClockDriftToleranceSeconds())
{
remoteSystemClockInSync = false;
// don't bring down the cluster if we lost a box and when the box is
// restarted, its system clock is out of sync; just ignore that
// TaskManager, and send it a message to terminate itself
if (currentTime <= clockDriftFatalTimePeriod)
if ((std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second)) > ConfigTaskManager::getMaximumClockDriftToleranceSeconds())
{
FATAL(true, ("System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld)", (std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getCurrentEpochTime()));
}
else
{
LOG("CustomerService", ("system_clock_mismatch:System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld). Telling remote TaskManager to terminate.", (std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getCurrentEpochTime()));
LOG("CustomerService", ("system_clock_mismatch:System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld)", (std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second)), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, msg.getValue().first.c_str(), getRemoteAddress().c_str(), msg.getValue().second));
GenericValueTypeMessage<std::pair<std::string, std::pair<long, long> > > systemTimeMismatchMessage("SystemTimeMismatchMessage", std::make_pair(TaskManager::getNodeLabel(), std::make_pair(static_cast<long>(currentTime), t.getCurrentEpochTime())));
send(systemTimeMismatchMessage);
}
}
}
if (remoteSystemClockInSync)
{
m_nodeLabel = new std::string(t.getCommandLine());
Locator::opened(*m_nodeLabel, this);
TaskManager::resendUnacknowledgedSpawnRequests(this, *m_nodeLabel);
}
}
else if (m.isType("SystemTimeMismatchMessage"))
{
GenericValueTypeMessage<std::pair<std::string, std::pair<long, long> > > msg(r);
FATAL((msg.getValue().first == "node0"), ("System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), self epoch (%ld)", (std::max(msg.getValue().second.first, msg.getValue().second.second) - std::min(msg.getValue().second.first, msg.getValue().second.second)), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), msg.getValue().second.first, msg.getValue().second.second));
}
else if(m.isType("TaskSpawnProcess"))
{
TaskSpawnProcess s(r);
if (TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()) == 0)
{
DEBUG_REPORT_LOG(true, ("Failed to spawn %s on this node\n", s.getProcessName().c_str()));
//send fail message back
}
else
{
TaskSpawnProcessAck ack(s.getTransactionId());
send(ack);
}
}
else if(m.isType("TaskUtilization"))
{
TaskUtilization util(r);
switch(util.getUtilType())
{
case TaskUtilization::SYSTEM_AVG:
{
if (m_nodeLabel)
{
m_remoteUtilAvg = util.getUtilAmount();
Locator::updateServerLoad(*m_nodeLabel, m_remoteUtilAvg);
// tell CentralServer about the system clock mismatch so it can report an alert to SOEMon
GenericValueTypeMessage<std::string> systemTimeMismatchMessage("SystemTimeMismatchNotification",
FormattedString<1024>().sprintf("%s: %s (%s) is off by %ld seconds", CalendarTime::convertEpochToTimeStringLocal(static_cast<time_t>(currentTime)).c_str(), msg.getValue().first.c_str(), getRemoteAddress().c_str(), (std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second))));
TaskManager::sendToCentralServer(systemTimeMismatchMessage);
}
}
break;
default:
}
case constcrc("TaskConnectionIdMessage") :
{
static long const clockDriftFatalTimePeriod = static_cast<long>(TaskManager::getStartTime()) + ConfigTaskManager::getClockDriftFatalIntervalSeconds();
long const currentTime = static_cast<long>(::time(nullptr));
TaskConnectionIdMessage t(r);
WARNING_STRICT_FATAL(t.getServerType() != TaskConnectionIdMessage::TaskManager,
("ManagerConnection received wrong type identifier"));
WARNING_STRICT_FATAL(m_nodeLabel, ("Received new taskconnectionIdMessage with an already named connection"));
FATAL((ConfigTaskManager::getVerifyClusterName() && (TaskManager::getNodeLabel() == "node0") && (t.getServerType() == TaskConnectionIdMessage::TaskManager) && (t.getClusterName() != std::string(ConfigTaskManager::getClusterName()))), ("Remote TaskManager %s (%s) reported cluster name (%s) that is different from my cluster name (%s)", t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getClusterName().c_str(), ConfigTaskManager::getClusterName()));
// don't allow cluster to start if the system clock across the boxes are out of sync
bool remoteSystemClockInSync = true;
if (TaskManager::getNodeLabel() == "node0")
{
if ((std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())) > ConfigTaskManager::getMaximumClockDriftToleranceSeconds())
{
remoteSystemClockInSync = false;
// don't bring down the cluster if we lost a box and when the box is
// restarted, its system clock is out of sync; just ignore that
// TaskManager, and send it a message to terminate itself
if (currentTime <= clockDriftFatalTimePeriod)
{
FATAL(true, ("System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld)", (std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getCurrentEpochTime()));
}
else
{
LOG("CustomerService", ("system_clock_mismatch:System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), remote TaskManager %s (%s) epoch (%ld). Telling remote TaskManager to terminate.", (std::max(currentTime, t.getCurrentEpochTime()) - std::min(currentTime, t.getCurrentEpochTime())), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), currentTime, t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getCurrentEpochTime()));
GenericValueTypeMessage<std::pair<std::string, std::pair<long, long> > > systemTimeMismatchMessage("SystemTimeMismatchMessage", std::make_pair(TaskManager::getNodeLabel(), std::make_pair(static_cast<long>(currentTime), t.getCurrentEpochTime())));
send(systemTimeMismatchMessage);
}
}
}
if (remoteSystemClockInSync)
{
m_nodeLabel = new std::string(t.getCommandLine());
Locator::opened(*m_nodeLabel, this);
TaskManager::resendUnacknowledgedSpawnRequests(this, *m_nodeLabel);
}
break;
}
case constcrc("SystemTimeMismatchMessage") :
{
GenericValueTypeMessage<std::pair<std::string, std::pair<long, long> > > msg(r);
FATAL((msg.getValue().first == "node0"), ("System clock mismatch (%d seconds) by more than %d seconds: master TaskManager epoch (%ld), self epoch (%ld)", (std::max(msg.getValue().second.first, msg.getValue().second.second) - std::min(msg.getValue().second.first, msg.getValue().second.second)), ConfigTaskManager::getMaximumClockDriftToleranceSeconds(), msg.getValue().second.first, msg.getValue().second.second));
break;
}
case constcrc("TaskSpawnProcess") :
{
TaskSpawnProcess s(r);
if (TaskManager::startServer(s.getProcessName(), s.getOptions(), s.getTargetHostAddress(), s.getSpawnDelay()) == 0)
{
DEBUG_REPORT_LOG(true, ("Failed to spawn %s on this node\n", s.getProcessName().c_str()));
//send fail message back
}
else
{
TaskSpawnProcessAck ack(s.getTransactionId());
send(ack);
}
break;
}
case constcrc("TaskUtilization") :
{
TaskUtilization util(r);
switch(util.getUtilType())
{
case TaskUtilization::SYSTEM_AVG:
{
if (m_nodeLabel)
{
m_remoteUtilAvg = util.getUtilAmount();
Locator::updateServerLoad(*m_nodeLabel, m_remoteUtilAvg);
}
}
break;
default:
break;
}
break;
}
case constcrc("TaskProcessDiedMessage") :
{
TaskProcessDiedMessage died(r);
TaskManager::sendToCentralServer(died);
break;
}
case constcrc("TaskSpawnProcessAck") :
{
TaskSpawnProcessAck ack(r);
TaskManager::removePendingSpawnProcessAck(ack.getTransactionId());
break;
}
}
else if(m.isType("TaskProcessDiedMessage"))
{
TaskProcessDiedMessage died(r);
TaskManager::sendToCentralServer(died);
}
else if(m.isType("TaskSpawnProcessAck"))
{
TaskSpawnProcessAck ack(r);
TaskManager::removePendingSpawnProcessAck(ack.getTransactionId());
}
}
engine/server/application/TaskManager/src/shared/TaskConnection.cpp
+71 -60
View File
@@ -20,6 +20,8 @@
#include "serverNetworkMessages/TaskKillProcess.h"
#include "sharedNetwork/NetworkSetupData.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
TaskConnection::TaskConnection(const std::string & a, const unsigned short p) :
@@ -94,70 +96,79 @@ void TaskConnection::onReceive(const Archive::ByteStream & message)
Archive::ReadIterator r(message);
GameNetworkMessage m(r);
if(m.isType("TaskConnectionIdMessage"))
{
r = message.begin();
TaskConnectionIdMessage t(r);
FATAL((ConfigTaskManager::getVerifyClusterName() && (TaskManager::getNodeLabel() == "node0") && (t.getServerType() == TaskConnectionIdMessage::TaskManager) && (t.getClusterName() != std::string(ConfigTaskManager::getClusterName()))), ("Remote TaskManager %s (%s) reported cluster name (%s) that is different from my cluster name (%s)", t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getClusterName().c_str(), ConfigTaskManager::getClusterName()));
Identified i = {this, t.getServerType() };
identified.emitMessage(i);
switch(i.id)
const uint32 messageType = m.getType();
switch(messageType) {
case constcrc("TaskConnectionIdMessage") :
{
case TaskConnectionIdMessage::Central:
{
REPORT_LOG(true, ("New Central Server connection active\n"));
handler = new CentralConnection(this, t.getCommandLine());
TaskManager::setCentralConnection(this);
}
break;
case TaskConnectionIdMessage::Game:
{
REPORT_LOG(true, ("New Game Server connection active\n"));
handler = new GameConnection(this);
}
break;
case TaskConnectionIdMessage::Database:
{
REPORT_LOG(true, ("New Database Server connection active\n"));
handler = new DatabaseConnection();
}
break;
case TaskConnectionIdMessage::Metrics:
{
REPORT_LOG(true, ("New Metrics Server connection active\n"));
handler = new MetricsServerConnection(this, t.getCommandLine());
}
break;
case TaskConnectionIdMessage::Planet:
{
REPORT_LOG(true, ("New Planet Server connection active\n"));
handler = new PlanetConnection(this);
}
break;
r = message.begin();
TaskConnectionIdMessage t(r);
default:
WARNING_STRICT_FATAL(true, ("Unknown id (%d) received on task connection", i.id));
FATAL((ConfigTaskManager::getVerifyClusterName() && (TaskManager::getNodeLabel() == "node0") && (t.getServerType() == TaskConnectionIdMessage::TaskManager) && (t.getClusterName() != std::string(ConfigTaskManager::getClusterName()))), ("Remote TaskManager %s (%s) reported cluster name (%s) that is different from my cluster name (%s)", t.getCommandLine().c_str(), getRemoteAddress().c_str(), t.getClusterName().c_str(), ConfigTaskManager::getClusterName()));
Identified i = {this, t.getServerType() };
identified.emitMessage(i);
switch(i.id)
{
case TaskConnectionIdMessage::Central:
{
REPORT_LOG(true, ("New Central Server connection active\n"));
handler = new CentralConnection(this, t.getCommandLine());
TaskManager::setCentralConnection(this);
}
break;
case TaskConnectionIdMessage::Game:
{
REPORT_LOG(true, ("New Game Server connection active\n"));
handler = new GameConnection(this);
}
break;
case TaskConnectionIdMessage::Database:
{
REPORT_LOG(true, ("New Database Server connection active\n"));
handler = new DatabaseConnection();
}
break;
case TaskConnectionIdMessage::Metrics:
{
REPORT_LOG(true, ("New Metrics Server connection active\n"));
handler = new MetricsServerConnection(this, t.getCommandLine());
}
break;
case TaskConnectionIdMessage::Planet:
{
REPORT_LOG(true, ("New Planet Server connection active\n"));
handler = new PlanetConnection(this);
}
break;
default:
WARNING_STRICT_FATAL(true, ("Unknown id (%d) received on task connection", i.id));
break;
}
break;
}
case constcrc("ExcommunicateGameServerMessage") :
{
r = message.begin();
ExcommunicateGameServerMessage ex(r);
TaskKillProcess k(ex.getHostName(), ex.getProcessId(), true);
TaskManager::killProcess(k);
// broadcast to other task managers
Locator::sendToAllTaskManagers(k);
break;
}
case constcrc("TaskKillProcess") :
{
r = message.begin();
TaskKillProcess k(r);
TaskManager::killProcess(k);
break;
}
}
else if(m.isType("ExcommunicateGameServerMessage"))
{
r = message.begin();
ExcommunicateGameServerMessage ex(r);
TaskKillProcess k(ex.getHostName(), ex.getProcessId(), true);
TaskManager::killProcess(k);
// broadcast to other task managers
Locator::sendToAllTaskManagers(k);
}
else if(m.isType("TaskKillProcess"))
{
r = message.begin();
TaskKillProcess k(r);
TaskManager::killProcess(k);
}
msg.message = &message;
engine/server/application/TransferServer/src/shared/CentralServerConnection.cpp
+299 -274
View File
@@ -25,6 +25,8 @@
#include "sharedNetworkMessages/GenericValueTypeMessage.h"
#include "UnicodeUtils.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
namespace CentralServerConnectionNamespace
@@ -95,306 +97,329 @@ void CentralServerConnection::onReceive(const Archive::ByteStream & message)
Archive::ReadIterator ri = message.begin();
const GameNetworkMessage msg(ri);
ri = message.begin();
if(msg.isType("CentralGalaxyName"))
{
const GenericValueTypeMessage<std::string> cgn(ri);
setGalaxyName(cgn.getValue());
LOG("CustomerService", ("CharacterTransfer: Received CentralGalaxyName for %s", cgn.getValue().c_str()));
}
else if(msg.isType("UploadCharacterMessage"))
{
// receiving character data
const UploadCharacterMessage ucm(ri);
CharacterTransferData data;
data.stationId = ucm.getStationId();
data.fromGalaxy = m_galaxyName;
data.packedData = ucm.getPackedCharacterData();
bool result = TransferServer::uploadCharacterTransferData(data, ucm.getIsAdmin());
if(result)
const uint32 messageType = msg.getType();
switch(messageType) {
case constcrc("CentralGalaxyName") :
{
CharacterTransferStatusMessage uploadResult(ucm.getFromGameServerId(), ucm.getFromCharacterId(), "@base_player:upload_success");
send(uploadResult, true);
const GenericValueTypeMessage<std::string> cgn(ri);
setGalaxyName(cgn.getValue());
LOG("CustomerService", ("CharacterTransfer: Received CentralGalaxyName for %s", cgn.getValue().c_str()));
break;
}
else
case constcrc("UploadCharacterMessage") :
{
CharacterTransferStatusMessage uploadResult(ucm.getFromGameServerId(), ucm.getFromCharacterId(), "@base_player:upload_fail");
send(uploadResult, true);
}
}
else if(msg.isType("DownloadCharacterMessage"))
{
// retreive packed data from transfer server and
// send it to the requesting central server
const DownloadCharacterMessage dcm(ri);
const CharacterTransferData * data = TransferServer::getCharacterTransferData(dcm.getStationId(), m_galaxyName, dcm.getIsAdmin());
if(data)
{
const UploadCharacterMessage ucm(data->stationId, data->packedData, dcm.getGameServerId(), dcm.getToCharacterId(), true);
send(ucm, true);
LOG("CustomerService", ("CharacterTransfer: Character data for SUID %d downloaded\n", data->stationId));
}
else
{
CharacterTransferStatusMessage downloadResult(dcm.getGameServerId(), dcm.getToCharacterId(), "@base_player:download_fail");
send(downloadResult, true);
}
}
else if(msg.isType("AuthorizeDownload"))
{
const GenericValueTypeMessage<unsigned int> auth(ri);
TransferServer::authorizeDownload(auth.getValue());
}
else if(msg.isType("UnauthorizeDownload"))
{
const GenericValueTypeMessage<unsigned int> auth(ri);
TransferServer::unauthorizeDownload(auth.getValue());
}
else if(msg.isType("TransferReplyCharacterList"))
{
const TransferReplyCharacterList reply(ri);
// TESTING!
LOG("CustomerService", ("CharacterTransfer: Received character list for station id %d\n", reply.getStationId()));
const std::vector<AvatarRecord> & avatarList = reply.getAvatarList();
std::vector<AvatarRecord>::const_iterator i;
LOG("CustomerService", ("CharacterTransfer: Enumerating %d characters", avatarList.size()));
for(i = avatarList.begin() ; i != avatarList.end(); ++i)
{
LOG("CustomerService", ("CharacterTransfer: m_name = \"%s\" m_networkId = %s\n", Unicode::wideToNarrow(i->m_name).c_str(), i->m_networkId.getValueString().c_str()));
}
// TESTING END
TransferServer::replyCharacterList(reply);
}
else if(msg.isType("TransferReplyMoveValidation"))
{
const TransferReplyMoveValidation reply(ri);
if(reply.getResult() == TransferReplyMoveValidation::TRMVR_can_create_regular_character)
{
// save off the source character's template crc so it can be used in
// subsequent TransferRequestMoveValidation queries, so the LoginServer
// doesn't have to continually query the DB to fetch the same information
// over and over again, because the character's template crc
// (i.e. the character's species) should never, ever change
TransferServer::cacheSourceCharacterTemplateCrc(reply.getSourceStationId(), reply.getSourceGalaxy(), reply.getSourceCharacter(), reply.getSourceCharacterTemplateId());
TransferCharacterData requestData(reply.getTransferRequestSource());
requestData.setTrack(reply.getTrack());
requestData.setCustomerLocalizedLanguage(reply.getCustomerLocalizedLanguage());
requestData.setSourceGalaxy(reply.getSourceGalaxy());
requestData.setDestinationGalaxy(reply.getDestinationGalaxy());
requestData.setSourceCharacterName(reply.getSourceCharacter());
requestData.setObjectTemplateCrc(reply.getSourceCharacterTemplateId());
requestData.setDestinationCharacterName(reply.getDestinationCharacter());
requestData.setSourceStationId(reply.getSourceStationId());
requestData.setDestinationStationId(reply.getDestinationStationId());
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation("TransferRequestNameValidation", requestData);
CentralServerConnection * destinationConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getDestinationGalaxy());
LOG("CustomerService", ("CharacterTransfer: Received TransferReplyMoveValidation for %s on %s to %s on %s from CentralServer. Sending TransferRequestNameValidation to destination CentralServer.", reply.getSourceCharacter().c_str(), reply.getSourceGalaxy().c_str(), reply.getDestinationCharacter().c_str(), reply.getDestinationGalaxy().c_str()));
const GenericValueTypeMessage<std::pair<unsigned int, unsigned int> > kick("TransferRequestKickConnectedClients", std::make_pair(requestData.getSourceStationId(), requestData.getDestinationStationId()));
if(destinationConnection)
// receiving character data
const UploadCharacterMessage ucm(ri);
CharacterTransferData data;
data.stationId = ucm.getStationId();
data.fromGalaxy = m_galaxyName;
data.packedData = ucm.getPackedCharacterData();
bool result = TransferServer::uploadCharacterTransferData(data, ucm.getIsAdmin());
if(result)
{
destinationConnection->send(requestNameValidation, true);
destinationConnection->send(kick, true);
CharacterTransferStatusMessage uploadResult(ucm.getFromGameServerId(), ucm.getFromCharacterId(), "@base_player:upload_success");
send(uploadResult, true);
}
CentralServerConnection * sourceConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getSourceGalaxy());
if(sourceConnection)
else
{
sourceConnection->send(kick, true);
CharacterTransferStatusMessage uploadResult(ucm.getFromGameServerId(), ucm.getFromCharacterId(), "@base_player:upload_fail");
send(uploadResult, true);
}
break;
}
else
case constcrc("DownloadCharacterMessage") :
{
LOG("CustomerService", ("CharacterTransfer: TransferReplyMoveValidation failed for %s on %s to %s on %s from CentralServer because the account cannot create a new character on the destination server", reply.getSourceCharacter().c_str(), reply.getSourceGalaxy().c_str(), reply.getDestinationCharacter().c_str(), reply.getDestinationGalaxy().c_str()));
TransferServer::failedToValidateTransfer(reply);
}
}
else if(msg.isType("TransferReplyNameValidation"))
{
const GenericValueTypeMessage<std::pair<std::string, TransferCharacterData> > replyNameValidation(ri);
if(!replyNameValidation.getValue().second.getIsMoveRequest())
{
LOG("CustomerService", ("CharacterTransfer: Received replyNameValidation for move validation request. (%s) %s", replyNameValidation.getValue().first.c_str(), replyNameValidation.getValue().second.toString().c_str()));
TransferServer::replyValidateMove(replyNameValidation.getValue().second);
}
else
{
if(TransferServer::isRename(replyNameValidation.getValue().second))
// retreive packed data from transfer server and
// send it to the requesting central server
const DownloadCharacterMessage dcm(ri);
const CharacterTransferData * data = TransferServer::getCharacterTransferData(dcm.getStationId(), m_galaxyName, dcm.getIsAdmin());
if(data)
{
LOG("CustomerService", ("CharacterTransfer: Received replyNameValidation for rename request, starting character rename protocol. (%s) %s", replyNameValidation.getValue().first.c_str(), replyNameValidation.getValue().second.toString().c_str()));
const GenericValueTypeMessage<TransferCharacterData> renameCharacter("TransferRenameCharacter", replyNameValidation.getValue().second);
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(replyNameValidation.getValue().second.getSourceGalaxy());
if(centralServerConnection)
const UploadCharacterMessage ucm(data->stationId, data->packedData, dcm.getGameServerId(), dcm.getToCharacterId(), true);
send(ucm, true);
LOG("CustomerService", ("CharacterTransfer: Character data for SUID %d downloaded\n", data->stationId));
}
else
{
CharacterTransferStatusMessage downloadResult(dcm.getGameServerId(), dcm.getToCharacterId(), "@base_player:download_fail");
send(downloadResult, true);
}
break;
}
case constcrc("AuthorizeDownload") :
{
const GenericValueTypeMessage<unsigned int> auth(ri);
TransferServer::authorizeDownload(auth.getValue());
break;
}
case constcrc("UnauthorizeDownload") :
{
const GenericValueTypeMessage<unsigned int> auth(ri);
TransferServer::unauthorizeDownload(auth.getValue());
break;
}
case constcrc("TransferReplyCharacterList") :
{
const TransferReplyCharacterList reply(ri);
// TESTING!
LOG("CustomerService", ("CharacterTransfer: Received character list for station id %d\n", reply.getStationId()));
const std::vector<AvatarRecord> & avatarList = reply.getAvatarList();
std::vector<AvatarRecord>::const_iterator i;
LOG("CustomerService", ("CharacterTransfer: Enumerating %d characters", avatarList.size()));
for(i = avatarList.begin() ; i != avatarList.end(); ++i)
{
LOG("CustomerService", ("CharacterTransfer: m_name = \"%s\" m_networkId = %s\n", Unicode::wideToNarrow(i->m_name).c_str(), i->m_networkId.getValueString().c_str()));
}
// TESTING END
TransferServer::replyCharacterList(reply);
break;
}
case constcrc("TransferReplyMoveValidation") :
{
const TransferReplyMoveValidation reply(ri);
if(reply.getResult() == TransferReplyMoveValidation::TRMVR_can_create_regular_character)
{
// save off the source character's template crc so it can be used in
// subsequent TransferRequestMoveValidation queries, so the LoginServer
// doesn't have to continually query the DB to fetch the same information
// over and over again, because the character's template crc
// (i.e. the character's species) should never, ever change
TransferServer::cacheSourceCharacterTemplateCrc(reply.getSourceStationId(), reply.getSourceGalaxy(), reply.getSourceCharacter(), reply.getSourceCharacterTemplateId());
TransferCharacterData requestData(reply.getTransferRequestSource());
requestData.setTrack(reply.getTrack());
requestData.setCustomerLocalizedLanguage(reply.getCustomerLocalizedLanguage());
requestData.setSourceGalaxy(reply.getSourceGalaxy());
requestData.setDestinationGalaxy(reply.getDestinationGalaxy());
requestData.setSourceCharacterName(reply.getSourceCharacter());
requestData.setObjectTemplateCrc(reply.getSourceCharacterTemplateId());
requestData.setDestinationCharacterName(reply.getDestinationCharacter());
requestData.setSourceStationId(reply.getSourceStationId());
requestData.setDestinationStationId(reply.getDestinationStationId());
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation("TransferRequestNameValidation", requestData);
CentralServerConnection * destinationConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getDestinationGalaxy());
LOG("CustomerService", ("CharacterTransfer: Received TransferReplyMoveValidation for %s on %s to %s on %s from CentralServer. Sending TransferRequestNameValidation to destination CentralServer.", reply.getSourceCharacter().c_str(), reply.getSourceGalaxy().c_str(), reply.getDestinationCharacter().c_str(), reply.getDestinationGalaxy().c_str()));
const GenericValueTypeMessage<std::pair<unsigned int, unsigned int> > kick("TransferRequestKickConnectedClients", std::make_pair(requestData.getSourceStationId(), requestData.getDestinationStationId()));
if(destinationConnection)
{
centralServerConnection->send(renameCharacter, true);
destinationConnection->send(requestNameValidation, true);
destinationConnection->send(kick, true);
}
else
CentralServerConnection * sourceConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getSourceGalaxy());
if(sourceConnection)
{
TransferServer::transferCreateCharacterFailed(replyNameValidation.getValue().second);
sourceConnection->send(kick, true);
}
}
else
{
DEBUG_FATAL(true, ("Received TransferReplyNameValidation for a move request that is not a rename!"));
LOG("CustomerService", ("CharacterTransfer: TransferReplyMoveValidation failed for %s on %s to %s on %s from CentralServer because the account cannot create a new character on the destination server", reply.getSourceCharacter().c_str(), reply.getSourceGalaxy().c_str(), reply.getDestinationCharacter().c_str(), reply.getDestinationGalaxy().c_str()));
TransferServer::failedToValidateTransfer(reply);
}
break;
}
}
else if(msg.isType("TransferReplyCharacterDataFromLoginServer"))
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReplyCharacterDataFromLoginServer, characterId=%s\n", reply.getValue().getCharacterId().getValueString().c_str()));
// is this a transfer or a rename?
if(TransferServer::isRename(reply.getValue()))
case constcrc("TransferReplyNameValidation") :
{
LOG("CustomerService", ("CharacterTransfer: Sending TransferRequestNameValidation for character rename request: %s", reply.getValue().toString().c_str()));
// send a name validation request
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation("TransferRequestNameValidation", reply.getValue());
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getValue().getSourceGalaxy());
const GenericValueTypeMessage<std::pair<std::string, TransferCharacterData> > replyNameValidation(ri);
if(!replyNameValidation.getValue().second.getIsMoveRequest())
{
LOG("CustomerService", ("CharacterTransfer: Received replyNameValidation for move validation request. (%s) %s", replyNameValidation.getValue().first.c_str(), replyNameValidation.getValue().second.toString().c_str()));
TransferServer::replyValidateMove(replyNameValidation.getValue().second);
}
else
{
if(TransferServer::isRename(replyNameValidation.getValue().second))
{
LOG("CustomerService", ("CharacterTransfer: Received replyNameValidation for rename request, starting character rename protocol. (%s) %s", replyNameValidation.getValue().first.c_str(), replyNameValidation.getValue().second.toString().c_str()));
const GenericValueTypeMessage<TransferCharacterData> renameCharacter("TransferRenameCharacter", replyNameValidation.getValue().second);
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(replyNameValidation.getValue().second.getSourceGalaxy());
if(centralServerConnection)
{
centralServerConnection->send(renameCharacter, true);
}
else
{
TransferServer::transferCreateCharacterFailed(replyNameValidation.getValue().second);
}
}
else
{
DEBUG_FATAL(true, ("Received TransferReplyNameValidation for a move request that is not a rename!"));
}
}
break;
}
case constcrc("TransferReplyCharacterDataFromLoginServer") :
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReplyCharacterDataFromLoginServer, characterId=%s\n", reply.getValue().getCharacterId().getValueString().c_str()));
// is this a transfer or a rename?
if(TransferServer::isRename(reply.getValue()))
{
LOG("CustomerService", ("CharacterTransfer: Sending TransferRequestNameValidation for character rename request: %s", reply.getValue().toString().c_str()));
// send a name validation request
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation("TransferRequestNameValidation", reply.getValue());
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(reply.getValue().getSourceGalaxy());
if(centralServerConnection)
{
centralServerConnection->send(requestNameValidation, true);
}
}
else
{
// this is a transfer
TransferServer::getLoginLocationData(reply.getValue());
}
break;
}
case constcrc("TransferReplyLoginLocationData") :
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReplyLoginLocationData from CentralServer. TransferCharacterData=%s\n", reply.getValue().toString().c_str()));
// send character to ConnectionServer for login to a game server
const GenericValueTypeMessage<TransferCharacterData> login("TransferLoginCharacterToSourceServer", reply.getValue());
LOG("CustomerService", ("CharacterTransfer: Sending TransferLoginCharacterToSourceServer to CentralServer : %s", login.getValue().toString().c_str()));
send(login, true);
break;
}
case constcrc("TransferReceiveDataFromGameServer") :
{
const GenericValueTypeMessage<TransferCharacterData> transferReply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReceiveDataFromGameServer: %s", transferReply.getValue().toString().c_str()));
REPORT_LOG(true, ("Got TransferReceiveDataFromGameServer: %s\n", transferReply.getValue().toString().c_str()));
// find a central server connection for the target cluster
CentralServerConnection * destinationCentralConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(transferReply.getValue().getDestinationGalaxy());
if(destinationCentralConnection)
{
// send character to ConnectionServer for creation on the destination server
GenericValueTypeMessage<TransferCharacterData> login("TransferLoginCharacterToDestinationServer", transferReply.getValue());
destinationCentralConnection->send(login, true);
LOG("CustomerService", ("CharacterTransfer: Sending TransferLoginCharacterToDestinationServer to CentralServer (%s) for (%s)", transferReply.getValue().getDestinationGalaxy().c_str(), login.getValue().toString().c_str()));
}
else
{
//@todo: report error to CTS API
LOG("CustomerService", ("CharacterTransfer: Failed to get a CentralServer connection for %s", transferReply.getValue().getDestinationGalaxy().c_str()));
TransferServer::transferCreateCharacterFailed(transferReply.getValue());
}
break;
}
case constcrc("ApplyTransferDataSuccess") :
{
const GenericValueTypeMessage<TransferCharacterData> success(ri);
LOG("CustomerService", ("CharacterTransfer: Received ApplyTransferDataSuccess from target galaxy. %s", success.getValue().toString().c_str()));
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(success.getValue().getSourceGalaxy());
if(centralServerConnection)
{
centralServerConnection->send(requestNameValidation, true);
LOG("CustomerService", ("CharacterTransfer: Sending ToggleAvatarLoginStatus request to source central server"));
const ToggleAvatarLoginStatus toggleLoginStatus(success.getValue().getSourceGalaxy(), success.getValue().getSourceStationId(), success.getValue().getCharacterId(), false);
centralServerConnection->send(toggleLoginStatus, true);
TransferServer::replyMoveSuccess(success.getValue());
LOG("CustomerService", ("CharacterTransfer: TRANSFER SUCCESSFUL for transactionId=%u", success.getValue().getTransactionId()));
}
else
{
LOG("CustomerService", ("CharacterTransfer: Transfer failed on target galaxy : %s", success.getValue().toString().c_str()));
TransferServer::transferCreateCharacterFailed(success.getValue());
}
break;
}
else
case constcrc("ApplyTransferDataFail") :
{
// this is a transfer
TransferServer::getLoginLocationData(reply.getValue());
}
}
else if(msg.isType("TransferReplyLoginLocationData"))
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReplyLoginLocationData from CentralServer. TransferCharacterData=%s\n", reply.getValue().toString().c_str()));
// send character to ConnectionServer for login to a game server
const GenericValueTypeMessage<TransferCharacterData> login("TransferLoginCharacterToSourceServer", reply.getValue());
LOG("CustomerService", ("CharacterTransfer: Sending TransferLoginCharacterToSourceServer to CentralServer : %s", login.getValue().toString().c_str()));
send(login, true);
}
else if(msg.isType("TransferReceiveDataFromGameServer"))
{
const GenericValueTypeMessage<TransferCharacterData> transferReply(ri);
LOG("CustomerService", ("CharacterTransfer: Got TransferReceiveDataFromGameServer: %s", transferReply.getValue().toString().c_str()));
REPORT_LOG(true, ("Got TransferReceiveDataFromGameServer: %s\n", transferReply.getValue().toString().c_str()));
// find a central server connection for the target cluster
CentralServerConnection * destinationCentralConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(transferReply.getValue().getDestinationGalaxy());
if(destinationCentralConnection)
{
// send character to ConnectionServer for creation on the destination server
GenericValueTypeMessage<TransferCharacterData> login("TransferLoginCharacterToDestinationServer", transferReply.getValue());
destinationCentralConnection->send(login, true);
LOG("CustomerService", ("CharacterTransfer: Sending TransferLoginCharacterToDestinationServer to CentralServer (%s) for (%s)", transferReply.getValue().getDestinationGalaxy().c_str(), login.getValue().toString().c_str()));
}
else
{
//@todo: report error to CTS API
LOG("CustomerService", ("CharacterTransfer: Failed to get a CentralServer connection for %s", transferReply.getValue().getDestinationGalaxy().c_str()));
TransferServer::transferCreateCharacterFailed(transferReply.getValue());
}
}
else if(msg.isType("ApplyTransferDataSuccess"))
{
const GenericValueTypeMessage<TransferCharacterData> success(ri);
LOG("CustomerService", ("CharacterTransfer: Received ApplyTransferDataSuccess from target galaxy. %s", success.getValue().toString().c_str()));
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(success.getValue().getSourceGalaxy());
if(centralServerConnection)
{
LOG("CustomerService", ("CharacterTransfer: Sending ToggleAvatarLoginStatus request to source central server"));
const ToggleAvatarLoginStatus toggleLoginStatus(success.getValue().getSourceGalaxy(), success.getValue().getSourceStationId(), success.getValue().getCharacterId(), false);
centralServerConnection->send(toggleLoginStatus, true);
TransferServer::replyMoveSuccess(success.getValue());
LOG("CustomerService", ("CharacterTransfer: TRANSFER SUCCESSFUL for transactionId=%u", success.getValue().getTransactionId()));
}
else
{
LOG("CustomerService", ("CharacterTransfer: Transfer failed on target galaxy : %s", success.getValue().toString().c_str()));
TransferServer::transferCreateCharacterFailed(success.getValue());
}
}
else if(msg.isType("ApplyTransferDataFail"))
{
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
LOG("CustomerService", ("CharacterTransfer: Received ApplyTransferDataFail from target galaxy. %s", fail.getValue().toString().c_str()));
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(fail.getValue().getDestinationGalaxy());
if(centralServerConnection)
{
LOG("CustomerService", ("CharacterTransfer: failed to apply transfer data. Deleting character on destination server. %s", fail.getValue().toString().c_str()));
const GenericValueTypeMessage<TransferCharacterData> deleteCharacter("DeleteFailedTransfer", fail.getValue());
centralServerConnection->send(deleteCharacter, true);
TransferServer::failedToApplyTransferData(fail.getValue());
}
}
else if(msg.isType("TransferCreateCharacterFailed"))
{
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferCreateCharacterFailed, sending response to CTS API. %s", fail.getValue().toString().c_str()));
TransferServer::transferCreateCharacterFailed(fail.getValue());
}
else if(msg.isType("TransferRenameCharacterReply"))
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRenameCharacterReply from Central Server : %s", reply.getValue().toString().c_str()));
if(reply.getValue().getIsValidName())
{
TransferServer::replyMoveSuccess(reply.getValue());
}
else
{
TransferServer::transferCreateCharacterFailed(reply.getValue());
}
}
else if(msg.isType("TransferAccountReplySuccessTransferServer"))
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountReplySuccessTransferServer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::replyTransferAccountSuccess(reply.getValue());
}
else if(msg.isType("TransferAccountFailedToUpdateGameDatabase"))
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountFailedToUpdateGameDatabase for transfer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::failedToTransferAccountNoCentralConnection(reply.getValue());
}
else if(msg.isType("TransferAccountFailedDestinationNotEmpty"))
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountFailedDestinationNotEmpty for transfer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::failedToTransferAccountDestinationNotEmpty(reply.getValue());
}
else if(msg.isType("ReplyTransferDataFail"))
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
TransferServer::failedToRetrieveTransferData(reply.getValue());
}
else if(msg.isType("TransferFailGameServerClosedConnectionWithConnectionServer"))
{
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
TransferServer::failedToTransferCharacterGameConnectionClosed(fail.getValue());
}
else if(msg.isType("TransferFailConnectionServerClosedConnectionWithCentralServer"))
{
const GenericValueTypeMessage<unsigned int> fail(ri);
TransferServer::failedToTransferCharacterConnectionServerConnectionClosed(fail.getValue());
}
else if(msg.isType("ConGenericMessage"))
{
const ConGenericMessage cm(ri);
std::string result;
ConsoleManager::processString(cm.getMsg(), static_cast<const NetworkId::NetworkIdType>(cm.getMsgId()), result);
const ConGenericMessage response(result, cm.getMsgId());
send(response, true);
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
LOG("CustomerService", ("CharacterTransfer: Received ApplyTransferDataFail from target galaxy. %s", fail.getValue().toString().c_str()));
CentralServerConnection * centralServerConnection = CentralServerConnection::getCentralServerConnectionForGalaxy(fail.getValue().getDestinationGalaxy());
if(centralServerConnection)
{
LOG("CustomerService", ("CharacterTransfer: failed to apply transfer data. Deleting character on destination server. %s", fail.getValue().toString().c_str()));
const GenericValueTypeMessage<TransferCharacterData> deleteCharacter("DeleteFailedTransfer", fail.getValue());
centralServerConnection->send(deleteCharacter, true);
TransferServer::failedToApplyTransferData(fail.getValue());
}
break;
}
case constcrc("TransferCreateCharacterFailed") :
{
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferCreateCharacterFailed, sending response to CTS API. %s", fail.getValue().toString().c_str()));
TransferServer::transferCreateCharacterFailed(fail.getValue());
break;
}
case constcrc("TransferRenameCharacterReply") :
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRenameCharacterReply from Central Server : %s", reply.getValue().toString().c_str()));
if(reply.getValue().getIsValidName())
{
TransferServer::replyMoveSuccess(reply.getValue());
}
else
{
TransferServer::transferCreateCharacterFailed(reply.getValue());
}
break;
}
case constcrc("TransferAccountReplySuccessTransferServer") :
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountReplySuccessTransferServer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::replyTransferAccountSuccess(reply.getValue());
break;
}
case constcrc("TransferAccountFailedToUpdateGameDatabase") :
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountFailedToUpdateGameDatabase for transfer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::failedToTransferAccountNoCentralConnection(reply.getValue());
break;
}
case constcrc("TransferAccountFailedDestinationNotEmpty") :
{
const GenericValueTypeMessage<TransferAccountData> reply(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountFailedDestinationNotEmpty for transfer from station Id %d to station Id %d", reply.getValue().getSourceStationId(), reply.getValue().getDestinationStationId()));
TransferServer::failedToTransferAccountDestinationNotEmpty(reply.getValue());
break;
}
case constcrc("ReplyTransferDataFail") :
{
const GenericValueTypeMessage<TransferCharacterData> reply(ri);
TransferServer::failedToRetrieveTransferData(reply.getValue());
break;
}
case constcrc("TransferFailGameServerClosedConnectionWithConnectionServer") :
{
const GenericValueTypeMessage<TransferCharacterData> fail(ri);
TransferServer::failedToTransferCharacterGameConnectionClosed(fail.getValue());
break;
}
case constcrc("TransferFailConnectionServerClosedConnectionWithCentralServer") :
{
const GenericValueTypeMessage<unsigned int> fail(ri);
TransferServer::failedToTransferCharacterConnectionServerConnectionClosed(fail.getValue());
break;
}
case constcrc("ConGenericMessage") :
{
const ConGenericMessage cm(ri);
std::string result;
ConsoleManager::processString(cm.getMsg(), static_cast<const NetworkId::NetworkIdType>(cm.getMsgId()), result);
const ConGenericMessage response(result, cm.getMsgId());
send(response, true);
break;
}
}
}
engine/server/library/serverDatabase/src/shared/CentralServerConnection.cpp
+35 -25
View File
@@ -25,6 +25,8 @@
#include "Unicode.h"
#include "UnicodeUtils.h"
#include "sharedFoundation/CrcConstexpr.hpp"
// ======================================================================
CentralServerConnection::CentralServerConnection(const std::string & a, const unsigned short p) :
@@ -65,31 +67,39 @@ void CentralServerConnection::onReceive(const Archive::ByteStream & message)
const GameNetworkMessage msg(ri);
ri = message.begin();
if(msg.isType("TransferRenameCharacter"))
{
const GenericValueTypeMessage<TransferCharacterData> request(ri);
const TransferCharacterData & requestData = request.getValue();
LOG("CustomerService", ("CharacterTransfer: Received TransferRenameCharacter, starting game database name change. %s", requestData.toString().c_str()));
Persister::getInstance().renameCharacter(0, static_cast<int8>(RenameCharacterMessageEx::RCMS_cts_rename), request.getValue().getSourceStationId(), request.getValue().getCharacterId(), Unicode::narrowToWide(request.getValue().getDestinationCharacterName()), Unicode::narrowToWide(request.getValue().getSourceCharacterName()), false, NetworkId::cms_invalid, &requestData);
}
else if(msg.isType("ConGenericMessage"))
{
const ConGenericMessage cm(ri);
std::string result;
ConsoleManager::processString(cm.getMsg(), cm.getMsgId(), result);
const ConGenericMessage response(result, cm.getMsgId());
send(response, true);
}
else if(msg.isType("TransferAccountRequestCentralDatabase"))
{
const GenericValueTypeMessage<TransferAccountData> request(ri);
const TransferAccountData & requestData = request.getValue();
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountRequestCentralDatabase, starting game database change from station ID %d to station ID %d", request.getValue().getSourceStationId(), request.getValue().getDestinationStationId()));
Persister::getInstance().changeStationId(&requestData);
}
else
{
ServerConnection::onReceive(message);
const uint32 messageType = msg.getType();
switch(messageType) {
case constcrc("TransferRenameCharacter") :
{
const GenericValueTypeMessage<TransferCharacterData> request(ri);
const TransferCharacterData & requestData = request.getValue();
LOG("CustomerService", ("CharacterTransfer: Received TransferRenameCharacter, starting game database name change. %s", requestData.toString().c_str()));
Persister::getInstance().renameCharacter(0, static_cast<int8>(RenameCharacterMessageEx::RCMS_cts_rename), request.getValue().getSourceStationId(), request.getValue().getCharacterId(), Unicode::narrowToWide(request.getValue().getDestinationCharacterName()), Unicode::narrowToWide(request.getValue().getSourceCharacterName()), false, NetworkId::cms_invalid, &requestData);
break;
}
case constcrc("ConGenericMessage") :
{
const ConGenericMessage cm(ri);
std::string result;
ConsoleManager::processString(cm.getMsg(), cm.getMsgId(), result);
const ConGenericMessage response(result, cm.getMsgId());
send(response, true);
break;
}
case constcrc("TransferAccountRequestCentralDatabase") :
{
const GenericValueTypeMessage<TransferAccountData> request(ri);
const TransferAccountData & requestData = request.getValue();
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountRequestCentralDatabase, starting game database change from station ID %d to station ID %d", request.getValue().getSourceStationId(), request.getValue().getDestinationStationId()));
Persister::getInstance().changeStationId(&requestData);
break;
}
default :
{
ServerConnection::onReceive(message);
break;
}
}
}
engine/server/library/serverDatabase/src/shared/DataLookup.cpp
+61 -73
View File
@@ -28,6 +28,8 @@
#include "sharedNetworkMessages/NameErrors.h"
#include "unicodeArchive/UnicodeArchive.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
DataLookup *DataLookup::ms_theInstance = nullptr;
@@ -93,59 +95,71 @@ void DataLookup::receiveMessage(const MessageDispatch::Emitter &source, const Me
{
UNREF(source);
if (message.isType("VerifyNameRequest"))
{
const GameServerConnection * g = safe_cast<const GameServerConnection *>(&source);
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
VerifyNameRequest * vnr = new VerifyNameRequest(ri);
LOG("TraceCharacterCreation", ("%d received VerifyNameRequest", vnr->getStationId()));
verifyName(g->getProcessId(), vnr);
}
else if (message.isType("ReleaseNameMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ReleaseNameMessage rnm(ri);
const uint32 messageType = message.getType();
switch(messageType) {
case constcrc("VerifyNameRequest") :
{
const GameServerConnection * g = safe_cast<const GameServerConnection *>(&source);
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
VerifyNameRequest * vnr = new VerifyNameRequest(ri);
LOG("TraceCharacterCreation", ("%d received VerifyNameRequest", vnr->getStationId()));
verifyName(g->getProcessId(), vnr);
break;
}
case constcrc("ReleaseNameMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ReleaseNameMessage rnm(ri);
LOG("TraceCharacterCreation", ("%d received ReleaseNameMessage", rnm.getStationId()));
LOG("TraceCharacterCreation", ("%d received ReleaseNameMessage", rnm.getStationId()));
releaseName(rnm.getStationId(), rnm.getCharacterId());
}
else if (message.isType("RequestBiographyMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestBiographyMessage msg(ri);
releaseName(rnm.getStationId(), rnm.getCharacterId());
break;
}
case constcrc("RequestBiographyMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestBiographyMessage msg(ri);
const GameServerConnection *conn = dynamic_cast<const GameServerConnection*>(&source);
if (conn)
getBiography(msg.getOwner(),conn->getProcessId());
else
DEBUG_WARNING(true,("Got RequestBiographyMessage from something that wasn't a GameServerConnection.\n"));
}
else if (message.isType("BiographyMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BiographyMessage msg(ri);
const GameServerConnection *conn = dynamic_cast<const GameServerConnection*>(&source);
if (conn)
getBiography(msg.getOwner(),conn->getProcessId());
else
DEBUG_WARNING(true,("Got RequestBiographyMessage from something that wasn't a GameServerConnection.\n"));
break;
}
case constcrc("BiographyMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BiographyMessage msg(ri);
setBiography(msg.getOwner(),msg.getBio());
}
else if (message.isType("PurgeStructuresForAccountMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
setBiography(msg.getOwner(),msg.getBio());
break;
}
case constcrc("PurgeStructuresForAccountMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
getStructuresForPurge(msg.getValue(), false);
}
else if (message.isType("WarnStructuresAboutPurgeMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
getStructuresForPurge(msg.getValue(), false);
break;
}
case constcrc("WarnStructuresAboutPurgeMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
getStructuresForPurge(msg.getValue(), true);
}
else
{
DEBUG_REPORT_LOG(true,("Unrecognized message recieved by DataLookup.\n"));
getStructuresForPurge(msg.getValue(), true);
break;
}
default :
{
DEBUG_REPORT_LOG(true,("Unrecognized message recieved by DataLookup.\n"));
break;
}
}
}
@@ -454,32 +468,6 @@ const Unicode::String DataLookup::normalizeName(const Unicode::String &name) con
return result;
}
//--------------------------------------------------------------------
/*
const std::string DataLookup::getNameByStationId(uint32 stationId) const
{
std::map<uint32, reservation>::const_iterator i=m_reservations.find(stationId);
if (i == m_reservations.end())
{
WARNING_STRICT_FATAL(true, ("asked for name that wasn't in the reservation list"));
return std::string();
}
return Unicode::wideToNarrow(i->second.originalName);
}
//--------------------------------------------------------------------
const std::string DataLookup::getNormalizedNameByStationId(uint32 stationId) const
{
std::map<uint32, reservation>::const_iterator i=m_reservations.find(stationId);
if (i == m_reservations.end())
{
WARNING_STRICT_FATAL(true, ("asked for name that wasn't in the reservation list"));
return std::string();
}
return Unicode::wideToNarrow(i->second.name);
}
//--------------------------------------------------------------------
*/
DataLookup::reservationList * DataLookup::getReservationList(uint32 stationId)
engine/server/library/serverDatabase/src/shared/DatabaseProcess.cpp
+146 -125
View File
@@ -44,6 +44,8 @@
#include "sharedNetworkMessages/FrameEndMessage.h"
#include "UnicodeUtils.h"
#include "sharedFoundation/CrcConstexpr.hpp"
// ----------------------------------------------------------------------
DatabaseProcess *DatabaseProcess::ms_theInstance = nullptr;
@@ -418,143 +420,162 @@ void DatabaseProcess::gameServerGoByeBye(uint32 processId)
void DatabaseProcess::receiveMessage(const MessageDispatch::Emitter & source, const MessageDispatch::MessageBase & message)
{
UNREF(source);
const uint32 messageType = message.getType();
//---
// Connection info messages
//
if(message.isType("CentralConnectionOpened"))
{
DEBUG_REPORT_LOG(true, ("Connection with Central server opened\n"));
DEBUG_FATAL(centralServerConnection != &source,("Got CentralConnectionOpened from something other than our CentralServer connection.\n"));
//TODO: Make a DatabaseProcessConnect version of this message, perhaps ?
CentralGameServerConnect c("database", "127.0.0.1", 0, gameService->getBindAddress(), gameService->getBindPort());
centralServerConnection->send(c, true);
}
else if(message.isType("GameConnectionOpened"))
{
DEBUG_REPORT_LOG(true, ("Connection with Game server opened\n"));
}
else if(message.isType("TaskConnectionOpened"))
{
DEBUG_REPORT_LOG(true, ("Connection with Task manager opened\n"));
// get cluster name
std::string clusterName;
ConfigFile::Section const * const sec = ConfigFile::getSection("TaskManager");
if (sec)
switch(messageType) {
case constcrc("CentralConnectionOpened") :
{
ConfigFile::Key const * const ky = sec->findKey("clusterName");
if (ky)
DEBUG_REPORT_LOG(true, ("Connection with Central server opened\n"));
DEBUG_FATAL(centralServerConnection != &source,("Got CentralConnectionOpened from something other than our CentralServer connection.\n"));
//TODO: Make a DatabaseProcessConnect version of this message, perhaps ?
CentralGameServerConnect c("database", "127.0.0.1", 0, gameService->getBindAddress(), gameService->getBindPort());
centralServerConnection->send(c, true);
break;
}
case constcrc("GameConnectionOpened") :
{
DEBUG_REPORT_LOG(true, ("Connection with Game server opened\n"));
break;
}
case constcrc("TaskConnectionOpened") :
{
DEBUG_REPORT_LOG(true, ("Connection with Task manager opened\n"));
// get cluster name
std::string clusterName;
ConfigFile::Section const * const sec = ConfigFile::getSection("TaskManager");
if (sec)
{
clusterName = ky->getAsString(ky->getCount()-1, "");
ConfigFile::Key const * const ky = sec->findKey("clusterName");
if (ky)
{
clusterName = ky->getAsString(ky->getCount()-1, "");
}
}
TaskConnectionIdMessage tid(TaskConnectionIdMessage::Database, "", clusterName);
taskService->send(tid, true);
break;
}
TaskConnectionIdMessage tid(TaskConnectionIdMessage::Database, "", clusterName);
taskService->send(tid, true);
}
else if(message.isType("CommoditiesConnectionOpened"))
{
DEBUG_REPORT_LOG(true, ("Connection with Commodities Server opened\n"));
CommoditiesServerConnection * con = const_cast<CommoditiesServerConnection *>(static_cast<const CommoditiesServerConnection *>(&source));
if (commoditiesConnection)
LOG("CommoditiesConnectionOpened",("Connection Opened while another connection already exists."));
commoditiesConnection = con;
}
else if(message.isType("CentralConnectionClosed"))
{
DEBUG_REPORT_LOG(true, ("Central server closed its connection, we must die a tragicly heroic death.\n"));
setDone("CentralConnectionClosed : %s", centralServerConnection->getDisconnectReason().c_str());
centralServerConnection = 0;
WARNING(true,("Database lost connection to central."));
}
else if(message.isType("GameConnectionClosed"))
{
DEBUG_REPORT_LOG(true, ("a Game server closed its connection\n"));
}
else if(message.isType("TaskConnectionClosed"))
{
DEBUG_REPORT_LOG(true, ("Task manager closed its connection\n"));
taskService=0;
}
else if(message.isType("CommoditiesConnectionClosed"))
{
DEBUG_REPORT_LOG(true, ("Commodities Server closed its connection\n"));
commoditiesService = 0;
commoditiesConnection = 0;
}
// end connection info messages
//---
else if(message.isType("CentralGameServerSetProcessId"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CentralGameServerSetProcessId id(ri);
setProcessId(id.getProcessId());
clusterName = id.getClusterName();
Loader::getInstance().checkVersionNumber(ConfigServerDatabase::getExpectedDBVersion(), ConfigServerDatabase::isCorrectDBVersionRequired());
Loader::getInstance().loadClock();
}
else if(message.isType("GameSetProcessId") || message.isType("GameGameServerConnect"))
{
GameServerConnection * g = const_cast<GameServerConnection *>(static_cast<const GameServerConnection *>(&source));
gameServerConnections[g->getProcessId()] = g;
GameServerConnectAck reply;
g->send(reply,true);
}
else if(message.isType("ProfilerOperationMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ProfilerOperationMessage m(ri);
uint32 processId = m.getProcessId();
if (processId == 0 || processId == getProcessId())
Profiler::handleOperation(m.getOperation().c_str());
}
else if(message.isType("ChatServerOnline"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ChatServerOnline cso(ri);
// establish a connection with the chat server if one doesn't already exist
if (!chatServerConnection)
case constcrc("CommoditiesConnectionOpened") :
{
REPORT_LOG(true, ("New chat server connection active\n"));
chatServerConnection = new ChatServerConnection(cso.getAddress(), cso.getPort());
DEBUG_REPORT_LOG(true, ("Connection with Commodities Server opened\n"));
CommoditiesServerConnection * con = const_cast<CommoditiesServerConnection *>(static_cast<const CommoditiesServerConnection *>(&source));
if (commoditiesConnection)
LOG("CommoditiesConnectionOpened",("Connection Opened while another connection already exists."));
commoditiesConnection = con;
break;
}
}
else if(message.isType("ChatServerConnectionClosed"))
{
REPORT_LOG(true, ("DatabaseProcess: Chat Server connection closed\n"));
chatServerConnection = 0;
}
else if(message.isType("FrameEndMessage"))
{
// TODO: handle this game server's frame ending
}
else if (message.isType("CentralPingMessage"))
{
CentralPingMessage reply;
sendToCentralServer(reply,true);
}
else if (message.isType("ExcommunicateGameServerMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ExcommunicateGameServerMessage msg(ri);
LOG("GameGameConnect",("Database Process was told to drop connection to %lu by Central",msg.getServerId()));
FATAL (msg.getServerId() == getProcessId(),("Crashing because Central told us to (probably indicates we weren't responding to pings)"));
GameServerConnection *conn =getConnectionByProcess(msg.getServerId());
if (conn)
case constcrc("CentralConnectionClosed") :
{
conn->setDisconnectReason("Told to excommunicate by central");
conn->disconnect();
DEBUG_REPORT_LOG(true, ("Central server closed its connection, we must die a tragicly heroic death.\n"));
setDone("CentralConnectionClosed : %s", centralServerConnection->getDisconnectReason().c_str());
centralServerConnection = 0;
WARNING(true,("Database lost connection to central."));
break;
}
}
case constcrc("GameConnectionClosed") :
{
DEBUG_REPORT_LOG(true, ("a Game server closed its connection\n"));
break;
}
case constcrc("TaskConnectionClosed") :
{
DEBUG_REPORT_LOG(true, ("Task manager closed its connection\n"));
taskService = 0;
break;
}
case constcrc("CommoditiesConnectionClosed") :
{
DEBUG_REPORT_LOG(true, ("Commodities Server closed its connection\n"));
commoditiesService = 0;
commoditiesConnection = 0;
break;
}
// end connection info messages
case constcrc("CentralGameServerSetProcessId") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CentralGameServerSetProcessId id(ri);
setProcessId(id.getProcessId());
clusterName = id.getClusterName();
Loader::getInstance().checkVersionNumber(ConfigServerDatabase::getExpectedDBVersion(), ConfigServerDatabase::isCorrectDBVersionRequired());
Loader::getInstance().loadClock();
break;
}
case constcrc("GameSetProcessId") :
case constcrc("GameGameServerConnect") :
{
GameServerConnection * g = const_cast<GameServerConnection *>(static_cast<const GameServerConnection *>(&source));
gameServerConnections[g->getProcessId()] = g;
GameServerConnectAck reply;
g->send(reply,true);
break;
}
case constcrc("ProfilerOperationMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ProfilerOperationMessage m(ri);
uint32 processId = m.getProcessId();
if (processId == 0 || processId == getProcessId())
Profiler::handleOperation(m.getOperation().c_str());
break;
}
case constcrc("ChatServerOnline") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ChatServerOnline cso(ri);
// establish a connection with the chat server if one doesn't already exist
if (!chatServerConnection)
{
REPORT_LOG(true, ("New chat server connection active\n"));
chatServerConnection = new ChatServerConnection(cso.getAddress(), cso.getPort());
}
break;
}
case constcrc("ChatServerConnectionClosed") :
{
REPORT_LOG(true, ("DatabaseProcess: Chat Server connection closed\n"));
chatServerConnection = 0;
break;
}
case constcrc("FrameEndMessage") :
{
// TODO: handle this game server's frame ending
break;
}
case constcrc("CentralPingMessage") :
{
CentralPingMessage reply;
sendToCentralServer(reply,true);
break;
}
case constcrc("ExcommunicateGameServerMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ExcommunicateGameServerMessage msg(ri);
LOG("GameGameConnect",("Database Process was told to drop connection to %lu by Central",msg.getServerId()));
FATAL (msg.getServerId() == getProcessId(),("Crashing because Central told us to (probably indicates we weren't responding to pings)"));
GameServerConnection *conn =getConnectionByProcess(msg.getServerId());
if (conn)
{
conn->setDisconnectReason("Told to excommunicate by central");
conn->disconnect();
}
break;
}
}
}
// ----------------------------------------------------------------------
engine/server/library/serverDatabase/src/shared/Loader.cpp
+144 -117
View File
@@ -51,6 +51,8 @@
#include "sharedNetworkMessages/GenericValueTypeMessage.h"
#include "unicodeArchive/UnicodeArchive.h"
#include "sharedFoundation/CrcConstexpr.hpp"
#include <algorithm>
// ======================================================================
@@ -411,135 +413,160 @@ void Loader::queueOutgoingSnapshot(LoaderSnapshotGroup *outgoingSnapshot)
void Loader::receiveMessage(const MessageDispatch::Emitter & source, const MessageDispatch::MessageBase & message)
{
UNREF(source);
if(message.isType("LoadObjectMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadObjectMessage lom(ri);
DEBUG_FATAL(true,("LoadObjectMessage is deprecated on the database process.\n"));
// requestObject(lom.getId(),lom.getProcess());
}
else if(message.isType("RequestChunkMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestChunkMessage m(ri);
std::vector<RequestChunkMessage::Chunk> const & chunks = m.getChunks();
for (std::vector<RequestChunkMessage::Chunk>::const_iterator i=chunks.begin(); i!=chunks.end(); ++i)
requestChunk(i->m_process, i->m_nodeX, i->m_nodeZ, m.getSceneId());
}
else if(message.isType("RequestOIDsMessage"))
{
// DEBUG_REPORT_LOG(true,("Got RequestOIDsMessage.\n"));
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestOIDsMessage m(ri);
switch (messageType) {
case constcrc("LoadObjectMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadObjectMessage lom(ri);
DEBUG_FATAL(true,("LoadObjectMessage is deprecated on the database process.\n"));
// requestObject(lom.getId(),lom.getProcess());
break;
}
case constcrc("RequestChunkMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestChunkMessage m(ri);
std::vector<RequestChunkMessage::Chunk> const & chunks = m.getChunks();
for (std::vector<RequestChunkMessage::Chunk>::const_iterator i=chunks.begin(); i!=chunks.end(); ++i)
requestChunk(i->m_process, i->m_nodeX, i->m_nodeZ, m.getSceneId());
break;
}
case constcrc("RequestOIDsMessage") :
{
// DEBUG_REPORT_LOG(true,("Got RequestOIDsMessage.\n"));
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RequestOIDsMessage m(ri);
if (m.getLogRequest())
LOG("ObjectIdManager", ("Received RequestOIDsMessage for %lu more object ids for pid %lu", m.getHowMany(), m.getServerId()));
if (m.getLogRequest())
LOG("ObjectIdManager", ("Received RequestOIDsMessage for %lu more object ids for pid %lu", m.getHowMany(), m.getServerId()));
getObjectIds(static_cast<int>(m.getServerId()),static_cast<int>(m.getHowMany()), m.getLogRequest());
}
else if(message.isType("ValidateCharacterForLoginMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ValidateCharacterForLoginMessage msg(ri);
verifyCharacter(msg.getSuid(), msg.getCharacterId(), nullptr);
}
else if(message.isType("TransferGetLoginLocationData"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<TransferCharacterData> request(ri);
TransferCharacterData * transferData = new TransferCharacterData(request.getValue());
verifyCharacter(transferData->getSourceStationId(), transferData->getCharacterId(), transferData);
}//lint !e429 not freed : suppressed because verifyCharacter will own this copy of the data
else if(message.isType("LoadUniverseMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadUniverseMessage m(ri);
DEBUG_REPORT_LOG(true,("Got LoadUniverseMessage\n"));
loadUniverse(m.getProcess());
}
else if(message.isType("PlanetLoadCharacterMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
PlanetLoadCharacterMessage m(ri);
DEBUG_REPORT_LOG(true,("Got PlanetLoadCharacterMessage\n"));
requestCharacter(m.getCharacterId(), m.getGameServerId());
}
else if(message.isType("LoadContainedObjectMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadContainedObjectMessage msg(ri);
getObjectIds(static_cast<int>(m.getServerId()),static_cast<int>(m.getHowMany()), m.getLogRequest());
break;
}
case constcrc("ValidateCharacterForLoginMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ValidateCharacterForLoginMessage msg(ri);
verifyCharacter(msg.getSuid(), msg.getCharacterId(), nullptr);
break;
}
case constcrc("TransferGetLoginLocationData") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<TransferCharacterData> request(ri);
TransferCharacterData * transferData = new TransferCharacterData(request.getValue());
verifyCharacter(transferData->getSourceStationId(), transferData->getCharacterId(), transferData);
break;
}//lint !e429 not freed : suppressed because verifyCharacter will own this copy of the data
case constcrc("LoadUniverseMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadUniverseMessage m(ri);
DEBUG_REPORT_LOG(true,("Got LoadUniverseMessage\n"));
loadUniverse(m.getProcess());
break;
}
case constcrc("PlanetLoadCharacterMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
PlanetLoadCharacterMessage m(ri);
DEBUG_REPORT_LOG(true,("Got PlanetLoadCharacterMessage\n"));
requestCharacter(m.getCharacterId(), m.getGameServerId());
break;
}
case constcrc("LoadContainedObjectMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadContainedObjectMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
loadContainedObject(msg.getContainerId(), msg.getObjectId(), g->getProcessId());
else
WARNING_STRICT_FATAL(true,("Got LoadContainedObjectMessage for %s, but sender was not a GameServerConnection.\n",msg.getObjectId().getValueString().c_str()));
}
else if(message.isType("LoadContentsMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadContentsMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
loadContainedObject(msg.getContainerId(), msg.getObjectId(), g->getProcessId());
else
WARNING_STRICT_FATAL(true,("Got LoadContainedObjectMessage for %s, but sender was not a GameServerConnection.\n",msg.getObjectId().getValueString().c_str()));
break;
}
case constcrc("LoadContentsMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LoadContentsMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
loadContents(msg.getContainerId(), g->getProcessId());
else
WARNING_STRICT_FATAL(true,("Got LoadContentsMessage for container %s, but sender was not a GameServerConnection.\n",msg.getContainerId().getValueString().c_str()));
}
else if(message.isType("LocateStructureMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LocateStructureMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
loadContents(msg.getContainerId(), g->getProcessId());
else
WARNING_STRICT_FATAL(true,("Got LoadContentsMessage for container %s, but sender was not a GameServerConnection.\n",msg.getContainerId().getValueString().c_str()));
break;
}
case constcrc("LocateStructureMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
LocateStructureMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
locateStructure(msg.getStructureId(), msg.getWhoRequested());
else
WARNING_STRICT_FATAL(true,("Got LocateStructureMessage for %s, but sender was not a GameServerConnection.\n",msg.getStructureId().getValueString().c_str()));
}
else if(message.isType("PreloadRequestCompleteMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
PreloadRequestCompleteMessage msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
locateStructure(msg.getStructureId(), msg.getWhoRequested());
else
WARNING_STRICT_FATAL(true,("Got LocateStructureMessage for %s, but sender was not a GameServerConnection.\n",msg.getStructureId().getValueString().c_str()));
break;
}
case constcrc("PreloadRequestCompleteMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
PreloadRequestCompleteMessage msg(ri);
preloadRequestComplete(msg.getGameServerId(), msg.getPreloadAreaId());
}
else if(message.isType("LoadAckMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<int> msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
handleLoadAck(g->getProcessId(), msg.getValue());
else
WARNING_STRICT_FATAL(true,("Got LoadAckMessage, but sender was not a GameServerConnection."));
}
else if( message.isType("CSGetCharactersRequestMessage") )
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CSGetCharactersRequestMessage const msg( ri );
handleCSGetCharacters( msg );
}
else if( message.isType("CSGetDeletedItemsRequestMessage") )
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CSGetDeletedItemsRequestMessage const msg( ri );
handleCSGetDeletedItems( msg );
}
else if( message.isType("DBCSRequestMessage" ) )
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DBCSRequestMessage const msg( ri );
handleCSRequest( msg );
preloadRequestComplete(msg.getGameServerId(), msg.getPreloadAreaId());
break;
}
case constcrc("LoadAckMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<int> msg(ri);
const GameServerConnection * g = dynamic_cast<const GameServerConnection *>(&source);
if (g)
handleLoadAck(g->getProcessId(), msg.getValue());
else
WARNING_STRICT_FATAL(true,("Got LoadAckMessage, but sender was not a GameServerConnection."));
break;
}
case constcrc("CSGetCharactersRequestMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CSGetCharactersRequestMessage const msg( ri );
handleCSGetCharacters( msg );
break;
}
case constcrc("CSGetDeletedItemsRequestMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CSGetDeletedItemsRequestMessage const msg( ri );
handleCSGetDeletedItems( msg );
break;
}
case constcrc("DBCSRequestMessage" ) :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DBCSRequestMessage const msg( ri );
handleCSRequest( msg );
break;
}
}
}
void Loader::handleCSRequest( const DBCSRequestMessage & msg )
{
DEBUG_REPORT_LOG( true, ( "Message:%s\n", msg.getCommand().c_str() ) );
if( msg.getCommand() == "get_characters" )
// TODO : maybe constexpr this one sometime
if( == "get_characters" )
{
handleCSGetCharacters( msg );
}
engine/server/library/serverDatabase/src/shared/Persister.cpp
+274 -233
View File
@@ -65,6 +65,8 @@
#include "sharedNetworkMessages/GenericValueTypeMessage.h"
#include "sharedNetworkMessages/ObjectChannelMessages.h"
#include "sharedFoundation/CrcConstexpr.hpp"
#include <utility>
#include <algorithm>
@@ -650,243 +652,282 @@ void Persister::receiveMessage(const MessageDispatch::Emitter & source, const Me
if (gameConnection)
sourceGameServer = gameConnection->getProcessId();
if(message.isType("FlagObjectForDeleteMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
FlagObjectForDeleteMessage m(ri);
handleDeleteMessage(sourceGameServer, m.getId(),m.getReason(),m.getImmediate(),m.getDemandLoadedContainer(),m.getCascadeReason());
}
else if(message.isType("CreateObjectByCrcMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CreateObjectByCrcMessage t(ri);
// DEBUG_REPORT_LOG(true,("Got CreateObjectByCrcMessage for %s\n", t.getId().getValueString().c_str()));
newObject(sourceGameServer, t.getId(), t.getCrc(), t.getObjectType(), t.getContainer());
}
else if(message.isType("EndBaselinesMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
EndBaselinesMessage t(ri);
endBaselines(t.getId(),sourceGameServer);
}
else if(message.isType("DeltasMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DeltasMessage msg(ri);
handleDeltasMessage(sourceGameServer,msg);
}
else if(message.isType("BaselinesMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BaselinesMessage msg(ri);
handleBaselinesMessage(sourceGameServer,msg);
}
else if(message.isType("UpdateObjectPositionMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
UpdateObjectPositionMessage msg(ri);
getSnapshotForObject(msg.getNetworkId(), sourceGameServer).handleUpdateObjectPosition(msg);
}
else if(message.isType("AddCharacterMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
AddCharacterMessage ocm(ri);
DEBUG_REPORT_LOG(true, ("Got AddCharacterMessage for object %s.\n",ocm.getObjectId().getValueString().c_str()));
addCharacter(ocm.getAccountNumber(), ocm.getObjectId(), ocm.getProcess(), ocm.getName(), ocm.getSpecial());
}
else if (message.isType("UnloadObjectMessage"))
{
// TODO: keep track of when it's done saving so we know when we can reload it
}
else if (message.isType("MessageToMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
MessageToMessage m(ri);
handleMessageTo (sourceGameServer, m.getData());
}
else if (message.isType("MessageToAckMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
MessageToAckMessage m(ri);
handleMessageToAck (sourceGameServer, m.getMessageId());
}
else if (message.isType("ServerDeleteCharacterMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ServerDeleteCharacterMessage m(ri);
deleteCharacter(m.getStationId(), m.getCharacterId());
}
else if (message.isType("RenameCharacterMessageEx"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RenameCharacterMessageEx msg(ri);
renameCharacter(sourceGameServer, static_cast<int8>(msg.getRenameCharacterMessageSource()), msg.getStationId(), msg.getCharacterId(), msg.getNewName(), msg.getOldName(), msg.getLastNameChangeOnly(), msg.getRequestedBy(), nullptr);
}
else if (message.isType("UnloadedPlayerMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
UnloadedPlayerMessage msg(ri);
unloadCharacter(msg.getPlayerId(),sourceGameServer);
}
else if (message.isType("MoveToPlayer"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, NetworkId> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first, msg.getValue().second, -1, false, false);
}
else if (message.isType("MoveToPlayerBankMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, NetworkId> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first, msg.getValue().second, -1, true, false);
}
else if (message.isType("MoveToPlayerDatapadMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, int> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second, false, true);
}
else if (message.isType("FixLoadWith"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, int> > msg(ri);
fixLoadWith(sourceGameServer, msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second);
}
else if (message.isType("ClusterShutdownMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<bool> msg(ri);
m_clusterShuttingDown = msg.getValue();
}
else if (message.isType("StartSaveMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<NetworkId > msg(ri);
userRequestedSave(sourceGameServer, msg.getValue());
}
else if (message.isType("RestoreHouseMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
restoreHouse(msg.getValue().first, msg.getValue().second);
}
else if (message.isType("RestoreCharacterMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
restoreCharacter(msg.getValue().first, msg.getValue().second);
}
else if (message.isType("UndeleteItemMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
LOG("CustomerService", ("undeleteItem %s request from %s", msg.getValue().first.getValueString().c_str(), msg.getValue().second.c_str()));
undeleteItem(msg.getValue().first, msg.getValue().second);
}
else if (message.isType("MoveToPlayerMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, std::string> > msg(ri);
LOG("CustomerService", ("moveToPlayer %s, %s request from %s", msg.getValue().first.first.getValueString().c_str(), msg.getValue().first.second.getValueString().c_str(), msg.getValue().second.c_str()));
moveToPlayer(msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second);
}
else if (message.isType("CentralRequestSave"))
{
centralRequestedSave();
}
else if (message.isType("PlanetRequestSave"))
{
planetRequestedSave();
}
else if (message.isType("AddResourceTypeMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
AddResourceTypeMessage msg(ri);
handleAddResourceTypeMessage(sourceGameServer, msg);
}
else if (message.isType("BountyHunterTargetMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BountyHunterTargetMessage msg(ri);
getSnapshotForServer(sourceGameServer).handleBountyHunterTargetMessage(msg);
}
else if ( (message.isType("CMCreateAuctionMessage")) ||
(message.isType("CMCreateAuctionBidMessage")) ||
(message.isType("CMCreateLocationMessage")) ||
(message.isType("CMUpdateAuctionMessage")) ||
(message.isType("CMUpdateLocationMessage")) ||
(message.isType("CMDeleteAuctionMessage")) ||
(message.isType("CMDeleteLocationMessage")) )
{
const CommoditiesServerConnection * commConnection = dynamic_cast<const CommoditiesServerConnection *>(&source);
uint32 commServerId = 0;
if (commConnection)
commServerId = commConnection->getProcessId();
getCommoditiesSnapshot(commServerId).handleCommoditiesDataMessage(message);
}
else if (message.isType("LoadCommodities"))
{
if (m_commoditiesSnapshot)
const uint32 messageType = message.getType();
switch(messageType) {
case constcrc("FlagObjectForDeleteMessage") :
{
m_commoditiesSnapshot->startLoadAfterSaveComplete();
if (!isSaveInProgress())
m_startSaveWhenPossible = true;
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
FlagObjectForDeleteMessage m(ri);
handleDeleteMessage(sourceGameServer, m.getId(),m.getReason(),m.getImmediate(),m.getDemandLoadedContainer(),m.getCascadeReason());
break;
}
else
case constcrc("CreateObjectByCrcMessage") :
{
startLoadCommodities();
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
CreateObjectByCrcMessage t(ri);
// DEBUG_REPORT_LOG(true,("Got CreateObjectByCrcMessage for %s\n", t.getId().getValueString().c_str()));
newObject(sourceGameServer, t.getId(), t.getCrc(), t.getObjectType(), t.getContainer());
break;
}
case constcrc("EndBaselinesMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
EndBaselinesMessage t(ri);
endBaselines(t.getId(),sourceGameServer);
break;
}
case constcrc("DeltasMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DeltasMessage msg(ri);
handleDeltasMessage(sourceGameServer,msg);
break;
}
case constcrc("BaselinesMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BaselinesMessage msg(ri);
handleBaselinesMessage(sourceGameServer,msg);
break;
}
case constcrc("UpdateObjectPositionMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
UpdateObjectPositionMessage msg(ri);
getSnapshotForObject(msg.getNetworkId(), sourceGameServer).handleUpdateObjectPosition(msg);
break;
}
case constcrc("AddCharacterMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
AddCharacterMessage ocm(ri);
DEBUG_REPORT_LOG(true, ("Got AddCharacterMessage for object %s.\n",ocm.getObjectId().getValueString().c_str()));
addCharacter(ocm.getAccountNumber(), ocm.getObjectId(), ocm.getProcess(), ocm.getName(), ocm.getSpecial());
break;
}
case constcrc("UnloadObjectMessage") :
{
// TODO: keep track of when it's done saving so we know when we can reload it
break;
}
case constcrc("MessageToMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
MessageToMessage m(ri);
handleMessageTo (sourceGameServer, m.getData());
break;
}
case constcrc("MessageToAckMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
MessageToAckMessage m(ri);
handleMessageToAck (sourceGameServer, m.getMessageId());
break;
}
case constcrc("ServerDeleteCharacterMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ServerDeleteCharacterMessage m(ri);
deleteCharacter(m.getStationId(), m.getCharacterId());
break;
}
case constcrc("RenameCharacterMessageEx") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RenameCharacterMessageEx msg(ri);
renameCharacter(sourceGameServer, static_cast<int8>(msg.getRenameCharacterMessageSource()), msg.getStationId(), msg.getCharacterId(), msg.getNewName(), msg.getOldName(), msg.getLastNameChangeOnly(), msg.getRequestedBy(), nullptr);
break;
}
case constcrc("UnloadedPlayerMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
UnloadedPlayerMessage msg(ri);
unloadCharacter(msg.getPlayerId(),sourceGameServer);
break;
}
case constcrc("MoveToPlayer") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, NetworkId> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first, msg.getValue().second, -1, false, false);
break;
}
case constcrc("MoveToPlayerBankMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, NetworkId> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first, msg.getValue().second, -1, true, false);
break;
}
case constcrc("MoveToPlayerDatapadMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, int> > msg(ri);
moveToPlayer(sourceGameServer, msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second, false, true);
break;
}
case constcrc("FixLoadWith") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, int> > msg(ri);
fixLoadWith(sourceGameServer, msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second);
break;
}
case constcrc("ClusterShutdownMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<bool> msg(ri);
m_clusterShuttingDown = msg.getValue();
break;
}
case constcrc("StartSaveMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<NetworkId > msg(ri);
userRequestedSave(sourceGameServer, msg.getValue());
break;
}
case constcrc("RestoreHouseMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
restoreHouse(msg.getValue().first, msg.getValue().second);
break;
}
case constcrc("RestoreCharacterMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
restoreCharacter(msg.getValue().first, msg.getValue().second);
break;
}
case constcrc("UndeleteItemMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<NetworkId, std::string> > msg(ri);
LOG("CustomerService", ("undeleteItem %s request from %s", msg.getValue().first.getValueString().c_str(), msg.getValue().second.c_str()));
undeleteItem(msg.getValue().first, msg.getValue().second);
break;
}
case constcrc("MoveToPlayerMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<NetworkId, NetworkId>, std::string> > msg(ri);
LOG("CustomerService", ("moveToPlayer %s, %s request from %s", msg.getValue().first.first.getValueString().c_str(), msg.getValue().first.second.getValueString().c_str(), msg.getValue().second.c_str()));
moveToPlayer(msg.getValue().first.first, msg.getValue().first.second, msg.getValue().second);
break;
}
case constcrc("CentralRequestSave") :
{
centralRequestedSave();
break;
}
case constcrc("PlanetRequestSave") :
{
planetRequestedSave();
break;
}
case constcrc("AddResourceTypeMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
AddResourceTypeMessage msg(ri);
handleAddResourceTypeMessage(sourceGameServer, msg);
break;
}
case constcrc("BountyHunterTargetMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
BountyHunterTargetMessage msg(ri);
getSnapshotForServer(sourceGameServer).handleBountyHunterTargetMessage(msg);
break;
}
case constcrc("CMCreateAuctionMessage") :
case constcrc("CMCreateAuctionBidMessage") :
case constcrc("CMCreateLocationMessage") :
case constcrc("CMUpdateAuctionMessage") :
case constcrc("CMUpdateLocationMessage") :
case constcrc("CMDeleteAuctionMessage") :
case constcrc("CMDeleteLocationMessage") :
{
const CommoditiesServerConnection * commConnection = dynamic_cast<const CommoditiesServerConnection *>(&source);
uint32 commServerId = 0;
if (commConnection)
commServerId = commConnection->getProcessId();
getCommoditiesSnapshot(commServerId).handleCommoditiesDataMessage(message);
break;
}
case constcrc("LoadCommodities") :
{
if (m_commoditiesSnapshot)
{
m_commoditiesSnapshot->startLoadAfterSaveComplete();
if (!isSaveInProgress())
m_startSaveWhenPossible = true;
}
else
{
startLoadCommodities();
}
break;
}
case constcrc("GetMoneyFromOfflineObjectMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GetMoneyFromOfflineObjectMessage msg(ri);
getMoneyFromOfflineObject(sourceGameServer, msg.getSourceObject(), msg.getAmount(), msg.getReplyTo(), msg.getSuccessCallback(), msg.getFailCallback(), msg.getPackedDictionary());
break;
}
case constcrc("PurgeCompleteMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
handlePurgeCompleteMessage(sourceGameServer, msg.getValue());
break;
}
case constcrc("DBCSRequestMessage" ) :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DBCSRequestMessage const msg( ri );
handleCSRequest( msg );
break;
}
case constcrc("UndeleteItemForCsMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<std::pair<NetworkId, NetworkId>, std::string>, bool> > undeleteRequest(ri);
handleCsUndelete(undeleteRequest.getValue().first.first.first,
undeleteRequest.getValue().first.first.second,
undeleteRequest.getValue().first.second,
undeleteRequest.getValue().second);
break;
}
default :
{
DEBUG_REPORT_LOG(true,("Unrecognized message recieved by Persister.\n"));
break;
}
}
else if (message.isType("GetMoneyFromOfflineObjectMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GetMoneyFromOfflineObjectMessage msg(ri);
getMoneyFromOfflineObject(sourceGameServer, msg.getSourceObject(), msg.getAmount(), msg.getReplyTo(), msg.getSuccessCallback(), msg.getFailCallback(), msg.getPackedDictionary());
}
else if (message.isType("PurgeCompleteMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> msg(ri);
handlePurgeCompleteMessage(sourceGameServer, msg.getValue());
}
else if( message.isType("DBCSRequestMessage" ) )
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
DBCSRequestMessage const msg( ri );
handleCSRequest( msg );
}
else if (message.isType("UndeleteItemForCsMessage"))
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<std::pair<std::pair<NetworkId, NetworkId>, std::string>, bool> > undeleteRequest(ri);
handleCsUndelete(undeleteRequest.getValue().first.first.first,
undeleteRequest.getValue().first.first.second,
undeleteRequest.getValue().first.second,
undeleteRequest.getValue().second);
}
else
{
DEBUG_REPORT_LOG(true,("Unrecognized message recieved by Persister.\n"));
}
}
engine/server/library/serverGame/src/shared/core/ChatServerConnection.cpp
+93 -101
View File
@@ -25,7 +25,7 @@
#include "sharedNetwork/NetworkSetupData.h"
#include "sharedObject/NetworkIdManager.h"
#include "sharedNetworkMessages/VoiceChatMiscMessages.h"
#include "sharedFoundation/CrcConstexpr.hpp"
//-----------------------------------------------------------------------
@@ -60,114 +60,106 @@ void ChatServerConnection::onReceive(const Archive::ByteStream &message)
GameNetworkMessage msg(ri);
Archive::ReadIterator cri = message.begin();
const uint32 messageType = msg.getType();
if (msg.isType("ChatOnCreateRoom"))
{
ChatOnCreateRoom chat(cri);
GroupObject::onChatRoomCreate(chat.getRoomData().path);
GuildInterface::onChatRoomCreate(chat.getRoomData().path);
CityInterface::onChatRoomCreate(chat.getRoomData().path);
}
else if (msg.isType("ChatOnRequestLog"))
{
ChatOnRequestLog chatOnRequestLog(cri);
ReportManager::handleMessage(chatOnRequestLog);
}
else if (msg.isType("ChatAvatarConnected"))
{
GenericValueTypeMessage<NetworkId> m(cri);
Object *o = NetworkIdManager::getObjectById(m.getValue());
if (o)
switch(messageType) {
case constcrc("ChatOnCreateRoom") :
{
ServerObject *so = o->asServerObject();
if (so && so->isAuthoritative())
ChatOnCreateRoom chat(cri);
GroupObject::onChatRoomCreate(chat.getRoomData().path);
GuildInterface::onChatRoomCreate(chat.getRoomData().path);
CityInterface::onChatRoomCreate(chat.getRoomData().path);
break;
}
case constcrc("ChatOnRequestLog") :
{
ChatOnRequestLog chatOnRequestLog(cri);
ReportManager::handleMessage(chatOnRequestLog);
break;
}
case constcrc("ChatAvatarConnected") :
{
GenericValueTypeMessage<NetworkId> m(cri);
Object *o = NetworkIdManager::getObjectById(m.getValue());
if (o)
{
CreatureObject *co = so->asCreatureObject();
if (co)
ServerObject *so = o->asServerObject();
if (so && so->isAuthoritative())
{
if (co->getGuildId())
CreatureObject *co = so->asCreatureObject();
if (co)
{
GuildInterface::enterGuildChatRoom(*co);
GuildInterface::enterGuildVoiceChatRoom(*co);
if (co->getGuildId())
{
GuildInterface::enterGuildChatRoom(*co);
GuildInterface::enterGuildVoiceChatRoom(*co);
}
std::vector<int> const & cityIds = CityInterface::getCitizenOfCityId(co->getNetworkId());
if (!cityIds.empty())
CityInterface::enterCityChatRoom(cityIds.front(), *co);
}
GameScriptObject * gso = so->getScriptObject();
if(gso)
{
ScriptParams params;
gso->trigAllScripts(Scripting::TRIG_CHAT_ON_LOGIN, params);
}
}
}
break;
}
case constcrc("ChatAvatarRenamed") :
{
GenericValueTypeMessage<std::pair<std::string, std::string> > const m(cri);
// refresh the friends and/or ignore list of any character that
// has the renamed avatar in his friends and/or ignore list
std::string const oldName(NameManager::normalizeName(m.getValue().first));
std::string const newName(NameManager::normalizeName(m.getValue().second));
std::set<PlayerObject const *> const &players = PlayerObject::getAllPlayerObjects();
if (!players.empty())
{
std::set<PlayerObject const *>::const_iterator i;
for (i = players.begin(); i != players.end(); ++i)
{
PlayerObject const * const playerObject = *i;
if (!playerObject->isAuthoritative())
continue;
CreatureObject const * const creatureObject = playerObject->getCreatureObject();
if (!creatureObject || !creatureObject->isAuthoritative() || !creatureObject->getClient())
continue;
if (playerObject->isFriend(oldName))
{
// refresh friends list in 30 seconds
MessageToQueue::getInstance().sendMessageToC(playerObject->getNetworkId(),
"C++RequestChatFriendsList",
"",
30,
false);
Chat::sendSystemMessage(*creatureObject, Unicode::narrowToWide(FormattedString<2048>().sprintf("%s on your friends list has been renamed to %s. If your friends list has not been updated with the new name in about 30 seconds, you can relog to refresh your friends list.", oldName.c_str(), newName.c_str())), Unicode::emptyString);
}
std::vector<int> const & cityIds = CityInterface::getCitizenOfCityId(co->getNetworkId());
if (!cityIds.empty())
CityInterface::enterCityChatRoom(cityIds.front(), *co);
}
GameScriptObject * gso = so->getScriptObject();
if(gso)
{
ScriptParams params;
gso->trigAllScripts(Scripting::TRIG_CHAT_ON_LOGIN, params);
if (playerObject->isIgnoring(oldName))
{
// refresh ignore list in 30 seconds
MessageToQueue::getInstance().sendMessageToC(playerObject->getNetworkId(),
"C++RequestChatIgnoreList",
"",
30,
false);
Chat::sendSystemMessage(*creatureObject, Unicode::narrowToWide(FormattedString<2048>().sprintf("%s on your ignore list has been renamed to %s. If your ignore list has not been updated with the new name in about 30 seconds, you can relog to refresh your ignore list.", oldName.c_str(), newName.c_str())), Unicode::emptyString);
}
}
}
break;
}
}
else if (msg.isType("ChatAvatarRenamed"))
{
GenericValueTypeMessage<std::pair<std::string, std::string> > const m(cri);
// refresh the friends and/or ignore list of any character that
// has the renamed avatar in his friends and/or ignore list
std::string const oldName(NameManager::normalizeName(m.getValue().first));
std::string const newName(NameManager::normalizeName(m.getValue().second));
std::set<PlayerObject const *> const &players = PlayerObject::getAllPlayerObjects();
if (!players.empty())
{
std::set<PlayerObject const *>::const_iterator i;
for (i = players.begin(); i != players.end(); ++i)
{
PlayerObject const * const playerObject = *i;
if (!playerObject->isAuthoritative())
continue;
CreatureObject const * const creatureObject = playerObject->getCreatureObject();
if (!creatureObject || !creatureObject->isAuthoritative() || !creatureObject->getClient())
continue;
if (playerObject->isFriend(oldName))
{
// refresh friends list in 30 seconds
MessageToQueue::getInstance().sendMessageToC(playerObject->getNetworkId(),
"C++RequestChatFriendsList",
"",
30,
false);
Chat::sendSystemMessage(*creatureObject, Unicode::narrowToWide(FormattedString<2048>().sprintf("%s on your friends list has been renamed to %s. If your friends list has not been updated with the new name in about 30 seconds, you can relog to refresh your friends list.", oldName.c_str(), newName.c_str())), Unicode::emptyString);
}
if (playerObject->isIgnoring(oldName))
{
// refresh ignore list in 30 seconds
MessageToQueue::getInstance().sendMessageToC(playerObject->getNetworkId(),
"C++RequestChatIgnoreList",
"",
30,
false);
Chat::sendSystemMessage(*creatureObject, Unicode::narrowToWide(FormattedString<2048>().sprintf("%s on your ignore list has been renamed to %s. If your ignore list has not been updated with the new name in about 30 seconds, you can relog to refresh your ignore list.", oldName.c_str(), newName.c_str())), Unicode::emptyString);
}
}
}
}
else if (msg.isType(VoiceChatOnGetChannel::cms_name))
{
processVoiceChatOnGetChannel(message);
}
}
//-----------------------------------------------------------------------
void ChatServerConnection::processVoiceChatOnGetChannel(const Archive::ByteStream & message)
{
Archive::ReadIterator ri = message.begin();
VoiceChatOnGetChannel response(ri);
GroupObject::onVoiceChatRoomCreate(response.getRoomName());
GuildInterface::onVoiceChatRoomCreate(response.getRoomName());
//TODO: guild
}
}
engine/server/library/serverGame/src/shared/core/ChatServerConnection.h
-3
View File
@@ -23,9 +23,6 @@ public:
private:
ChatServerConnection & operator = (const ChatServerConnection & rhs);
ChatServerConnection(const ChatServerConnection & source);
void processVoiceChatOnGetChannel(const Archive::ByteStream & message);
};
//-----------------------------------------------------------------------
engine/server/library/serverGame/src/shared/core/Client.cpp
+1200 -1138
View File
File diff suppressed because it is too large Load Diff