mirror of
https://bitbucket.org/theswgsource/src-1.2.git
synced 2026-10-05 20:13:29 -04:00
226 lines
9.1 KiB
C++
Executable File
226 lines
9.1 KiB
C++
Executable File
// ManagerConnection.cpp
|
|
// Copyright 2000-01, Sony Online Entertainment Inc., all rights reserved.
|
|
// Author: Justin Randall
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
#include "FirstTaskManager.h"
|
|
#include "Locator.h"
|
|
#include "ManagerConnection.h"
|
|
#include "serverNetworkMessages/TaskProcessDiedMessage.h"
|
|
#include "serverNetworkMessages/TaskSpawnProcess.h"
|
|
#include "serverNetworkMessages/TaskSpawnProcessAck.h"
|
|
#include "serverNetworkMessages/TaskUtilization.h"
|
|
#include "serverNetworkMessages/TaskConnectionIdMessage.h"
|
|
#include "sharedFoundation/CalendarTime.h"
|
|
#include "sharedFoundation/Clock.h"
|
|
#include "sharedFoundation/FormattedString.h"
|
|
#include "sharedFoundation/Scheduler.h"
|
|
#include "sharedLog/Log.h"
|
|
#include "sharedMessageDispatch/Transceiver.h"
|
|
#include "sharedNetwork/NetworkSetupData.h"
|
|
#include "sharedNetworkMessages/GenericValueTypeMessage.h"
|
|
#include "ConfigTaskManager.h"
|
|
#include "TaskConnection.h"
|
|
#include "TaskManager.h"
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
namespace ManagerConnectionNamespace
|
|
{
|
|
int s_managerConnectionCount = 0;
|
|
}
|
|
|
|
using namespace ManagerConnectionNamespace;
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
ManagerConnection::ManagerConnection(const std::string & a, const unsigned short p) :
|
|
Connection(a,p, NetworkSetupData()),
|
|
m_nodeLabel(0),
|
|
m_remoteUtilAvg(100000.0f)
|
|
{
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
ManagerConnection::ManagerConnection(UdpConnectionMT * u, TcpClient * t) :
|
|
Connection(u, t),
|
|
m_nodeLabel(0),
|
|
m_remoteUtilAvg(100000.0f)
|
|
{
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
ManagerConnection::~ManagerConnection()
|
|
{
|
|
if (m_nodeLabel)
|
|
{
|
|
Locator::closed(*m_nodeLabel, this);
|
|
delete m_nodeLabel;
|
|
m_nodeLabel = 0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
void ManagerConnection::onConnectionClosed()
|
|
{
|
|
DEBUG_REPORT_LOG(true, ("Manager connection %s closed\n", getRemoteAddress().c_str()));
|
|
TaskManager::retryConnection(this);
|
|
if (m_nodeLabel)
|
|
{
|
|
Locator::closed(*m_nodeLabel, this);
|
|
delete m_nodeLabel;
|
|
m_nodeLabel = 0;
|
|
}
|
|
s_managerConnectionCount--;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void ManagerConnection::onConnectionOpened()
|
|
{
|
|
DEBUG_REPORT_LOG(true, ("Manager connection opened\n"));
|
|
TaskConnectionIdMessage id(TaskConnectionIdMessage::TaskManager, TaskManager::getNodeLabel(), ConfigTaskManager::getClusterName());
|
|
send(id);
|
|
s_managerConnectionCount++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
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")
|
|
{
|
|
if ((std::max(currentTime, msg.getValue().second) - std::min(currentTime, msg.getValue().second)) > ConfigTaskManager::getMaximumClockDriftToleranceSeconds())
|
|
{
|
|
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)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else if(m.isType("TaskProcessDiedMessage"))
|
|
{
|
|
TaskProcessDiedMessage died(r);
|
|
TaskManager::sendToCentralServer(died);
|
|
}
|
|
else if(m.isType("TaskSpawnProcessAck"))
|
|
{
|
|
TaskSpawnProcessAck ack(r);
|
|
TaskManager::removePendingSpawnProcessAck(ack.getTransactionId());
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void ManagerConnection::send(const GameNetworkMessage & message)
|
|
{
|
|
Archive::ByteStream b;
|
|
message.pack(b);
|
|
Connection::send(b, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
int ManagerConnection::getConnectionCount()
|
|
{
|
|
return s_managerConnectionCount;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|