361 lines
12 KiB
C++
361 lines
12 KiB
C++
#include "ServerProcess.h"
|
|
#include <QCoreApplication>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QDir>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QHostAddress>
|
|
|
|
namespace {
|
|
constexpr int kDefaultAdminPort = 7779;
|
|
constexpr int kAdminTimeoutMs = 3000;
|
|
constexpr auto kAdminTokenFileName = ".admin-token";
|
|
}
|
|
|
|
ServerProcess::ServerProcess(QObject *parent)
|
|
: QObject(parent)
|
|
, process(nullptr)
|
|
, running(false)
|
|
, m_adminPort(kDefaultAdminPort)
|
|
, adminFailCount(0)
|
|
{
|
|
pythonPath = findPythonExecutable();
|
|
serverDir = findServerDirectory();
|
|
}
|
|
|
|
ServerProcess::~ServerProcess() {
|
|
stop();
|
|
}
|
|
|
|
void ServerProcess::setAdminPort(int port) {
|
|
m_adminPort = (port > 0 && port <= 65535) ? port : kDefaultAdminPort;
|
|
}
|
|
|
|
int ServerProcess::adminPort() const {
|
|
return m_adminPort;
|
|
}
|
|
|
|
void ServerProcess::start(const QString &configPath) {
|
|
if (running) {
|
|
emit error("Server is already running");
|
|
return;
|
|
}
|
|
|
|
if (pythonPath.isEmpty()) {
|
|
emit error("Python not found. Please install Python 3.9+ and add it to PATH");
|
|
return;
|
|
}
|
|
|
|
if (serverDir.isEmpty()) {
|
|
emit error("Server directory not found");
|
|
return;
|
|
}
|
|
|
|
process = new QProcess(this);
|
|
connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),
|
|
this, SLOT(onProcessFinished(int, QProcess::ExitStatus)));
|
|
connect(process, SIGNAL(error(QProcess::ProcessError)),
|
|
this, SLOT(onProcessError(QProcess::ProcessError)));
|
|
connect(process, SIGNAL(readyReadStandardOutput()),
|
|
this, SLOT(onReadyReadStandardOutput()));
|
|
connect(process, SIGNAL(readyReadStandardError()),
|
|
this, SLOT(onReadyReadStandardError()));
|
|
connect(process, SIGNAL(started()),
|
|
this, SLOT(onProcessStarted()));
|
|
|
|
QStringList arguments;
|
|
arguments << "consumer_server_cli.py" << "serve" << "--config" << configPath;
|
|
|
|
process->setWorkingDirectory(serverDir);
|
|
process->start(pythonPath, arguments);
|
|
}
|
|
|
|
void ServerProcess::stop() {
|
|
if (!process) return;
|
|
|
|
if (process->state() == QProcess::Running) {
|
|
process->terminate();
|
|
if (!process->waitForFinished(3000)) {
|
|
process->kill();
|
|
process->waitForFinished();
|
|
}
|
|
}
|
|
|
|
running = false;
|
|
adminFailCount = 0;
|
|
}
|
|
|
|
QJsonObject ServerProcess::sendAdminCommand(const QJsonObject &request) {
|
|
if (serverDir.isEmpty()) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Server directory is unavailable for admin authentication")}
|
|
};
|
|
}
|
|
|
|
QFile tokenFile(QDir(serverDir).absoluteFilePath(QString::fromLatin1(kAdminTokenFileName)));
|
|
if (!tokenFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Admin authentication token is not available yet")}
|
|
};
|
|
}
|
|
const QByteArray token = tokenFile.readAll().trimmed();
|
|
tokenFile.close();
|
|
if (token.isEmpty()) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Admin authentication token is empty")}
|
|
};
|
|
}
|
|
|
|
QJsonObject authenticatedRequest = request;
|
|
authenticatedRequest.insert(QStringLiteral("adminToken"), QString::fromUtf8(token));
|
|
|
|
QTcpSocket socket;
|
|
socket.connectToHost(QStringLiteral("127.0.0.1"), static_cast<quint16>(m_adminPort));
|
|
if (!socket.waitForConnected(kAdminTimeoutMs)) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"),
|
|
QStringLiteral("Could not connect to admin port 127.0.0.1:%1 (%2)")
|
|
.arg(m_adminPort)
|
|
.arg(socket.errorString())}
|
|
};
|
|
}
|
|
|
|
const QByteArray payload = QJsonDocument(authenticatedRequest).toJson(QJsonDocument::Compact) + '\n';
|
|
if (socket.write(payload) < 0 || !socket.waitForBytesWritten(kAdminTimeoutMs)) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Failed to send admin command")}
|
|
};
|
|
}
|
|
|
|
QByteArray buffer;
|
|
while (!buffer.contains('\n')) {
|
|
if (!socket.waitForReadyRead(kAdminTimeoutMs)) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Timed out waiting for admin response")}
|
|
};
|
|
}
|
|
buffer += socket.readAll();
|
|
}
|
|
|
|
const int newline = buffer.indexOf('\n');
|
|
const QByteArray line = buffer.left(newline);
|
|
QJsonParseError parseError{};
|
|
const QJsonDocument doc = QJsonDocument::fromJson(line, &parseError);
|
|
if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
|
|
return QJsonObject{
|
|
{QStringLiteral("ok"), false},
|
|
{QStringLiteral("error"), QStringLiteral("Invalid admin response JSON")}
|
|
};
|
|
}
|
|
return doc.object();
|
|
}
|
|
|
|
void ServerProcess::fetchStats() {
|
|
if (!running) return;
|
|
|
|
const QJsonObject statsResponse = sendAdminCommand(QJsonObject{{QStringLiteral("cmd"), QStringLiteral("stats")}});
|
|
if (statsResponse.value(QStringLiteral("ok")).toBool()) {
|
|
adminFailCount = 0;
|
|
emit statsUpdated(statsResponse.value(QStringLiteral("data")).toObject());
|
|
} else {
|
|
++adminFailCount;
|
|
if (adminFailCount == 3 || adminFailCount == 10 || (adminFailCount % 30) == 0) {
|
|
emit logMessage(QStringLiteral("[ADMIN] %1")
|
|
.arg(statsResponse.value(QStringLiteral("error"))
|
|
.toString(QStringLiteral("Admin stats request failed."))));
|
|
}
|
|
return;
|
|
}
|
|
|
|
const QJsonObject clientsResponse = sendAdminCommand(QJsonObject{{QStringLiteral("cmd"), QStringLiteral("clients")}});
|
|
if (clientsResponse.value(QStringLiteral("ok")).toBool()) {
|
|
const QJsonObject data = clientsResponse.value(QStringLiteral("data")).toObject();
|
|
emit clientsUpdated(data.value(QStringLiteral("clients")).toArray());
|
|
} else {
|
|
emit logMessage(QStringLiteral("[ADMIN] %1")
|
|
.arg(clientsResponse.value(QStringLiteral("error"))
|
|
.toString(QStringLiteral("Admin clients request failed."))));
|
|
}
|
|
}
|
|
|
|
bool ServerProcess::kickPlayer(int playerId, const QString &reason) {
|
|
QJsonObject request{
|
|
{QStringLiteral("cmd"), QStringLiteral("kick")},
|
|
{QStringLiteral("playerId"), playerId},
|
|
{QStringLiteral("reason"), reason}
|
|
};
|
|
const QJsonObject response = sendAdminCommand(request);
|
|
const bool ok = response.value(QStringLiteral("ok")).toBool();
|
|
const QString message = ok
|
|
? response.value(QStringLiteral("message")).toString(QStringLiteral("Player kicked."))
|
|
: response.value(QStringLiteral("error")).toString(QStringLiteral("Kick failed."));
|
|
emit adminCommandFinished(ok, message);
|
|
return ok;
|
|
}
|
|
|
|
bool ServerProcess::banPlayer(int playerId, const QString &reason) {
|
|
QJsonObject request{
|
|
{QStringLiteral("cmd"), QStringLiteral("ban")},
|
|
{QStringLiteral("playerId"), playerId},
|
|
{QStringLiteral("reason"), reason}
|
|
};
|
|
const QJsonObject response = sendAdminCommand(request);
|
|
const bool ok = response.value(QStringLiteral("ok")).toBool();
|
|
const QString message = ok
|
|
? response.value(QStringLiteral("message")).toString(QStringLiteral("Player banned."))
|
|
: response.value(QStringLiteral("error")).toString(QStringLiteral("Ban failed."));
|
|
emit adminCommandFinished(ok, message);
|
|
if (ok) {
|
|
fetchStats();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool ServerProcess::unbanIp(const QString &ip) {
|
|
QJsonObject request{
|
|
{QStringLiteral("cmd"), QStringLiteral("unban")},
|
|
{QStringLiteral("ip"), ip}
|
|
};
|
|
const QJsonObject response = sendAdminCommand(request);
|
|
const bool ok = response.value(QStringLiteral("ok")).toBool();
|
|
const QString message = ok
|
|
? response.value(QStringLiteral("message")).toString(QStringLiteral("IP unbanned."))
|
|
: response.value(QStringLiteral("error")).toString(QStringLiteral("Unban failed."));
|
|
emit adminCommandFinished(ok, message);
|
|
return ok;
|
|
}
|
|
|
|
QJsonArray ServerProcess::listBans() {
|
|
const QJsonObject response = sendAdminCommand(QJsonObject{{QStringLiteral("cmd"), QStringLiteral("bans")}});
|
|
if (!response.value(QStringLiteral("ok")).toBool()) {
|
|
emit adminCommandFinished(
|
|
false,
|
|
response.value(QStringLiteral("error")).toString(QStringLiteral("Could not list bans.")));
|
|
return {};
|
|
}
|
|
return response.value(QStringLiteral("data")).toObject().value(QStringLiteral("bans")).toArray();
|
|
}
|
|
|
|
bool ServerProcess::isRunning() const {
|
|
return running && process && process->state() == QProcess::Running;
|
|
}
|
|
|
|
QString ServerProcess::serverDirectory() const {
|
|
return serverDir;
|
|
}
|
|
|
|
void ServerProcess::onProcessStarted() {
|
|
running = true;
|
|
adminFailCount = 0;
|
|
emit started();
|
|
}
|
|
|
|
void ServerProcess::onProcessFinished(int exitCode, QProcess::ExitStatus exitStatus) {
|
|
running = false;
|
|
adminFailCount = 0;
|
|
emit stopped();
|
|
|
|
if (exitStatus == QProcess::NormalExit) {
|
|
emit logMessage(QString("Server exited with code %1").arg(exitCode));
|
|
} else {
|
|
emit error("Server process crashed");
|
|
}
|
|
}
|
|
|
|
void ServerProcess::onProcessError(QProcess::ProcessError error) {
|
|
QString errorString;
|
|
switch (error) {
|
|
case QProcess::FailedToStart:
|
|
errorString = "Failed to start Python process";
|
|
break;
|
|
case QProcess::Crashed:
|
|
errorString = "Server process crashed";
|
|
break;
|
|
case QProcess::Timedout:
|
|
errorString = "Server process timed out";
|
|
break;
|
|
default:
|
|
errorString = "Unknown process error";
|
|
}
|
|
emit this->error(errorString);
|
|
}
|
|
|
|
void ServerProcess::onReadyReadStandardOutput() {
|
|
if (!process) return;
|
|
|
|
outputBuffer += process->readAllStandardOutput();
|
|
|
|
while (outputBuffer.contains('\n')) {
|
|
int newlinePos = outputBuffer.indexOf('\n');
|
|
QString line = outputBuffer.left(newlinePos);
|
|
outputBuffer = outputBuffer.mid(newlinePos + 1);
|
|
|
|
if (!line.isEmpty()) {
|
|
line = line.trimmed();
|
|
parseLogLine(line);
|
|
emit logMessage(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ServerProcess::onReadyReadStandardError() {
|
|
if (!process) return;
|
|
|
|
QString errorOutput = process->readAllStandardError();
|
|
emit logMessage("[STDERR] " + errorOutput);
|
|
}
|
|
|
|
QString ServerProcess::findPythonExecutable() {
|
|
QProcess proc;
|
|
proc.start("python", QStringList() << "--version");
|
|
if (proc.waitForFinished(2000)) {
|
|
return "python";
|
|
}
|
|
|
|
proc.start("python3", QStringList() << "--version");
|
|
if (proc.waitForFinished(2000)) {
|
|
return "python3";
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
QString ServerProcess::findServerDirectory() {
|
|
QDir dir(QCoreApplication::applicationDirPath());
|
|
for (int i = 0; i < 8; ++i) {
|
|
const QString candidate = dir.absoluteFilePath(QStringLiteral("server"));
|
|
if (QFileInfo::exists(candidate + QStringLiteral("/consumer_server_cli.py")) &&
|
|
QFileInfo::exists(candidate + QStringLiteral("/admin_server.py"))) {
|
|
return QFileInfo(candidate).absoluteFilePath();
|
|
}
|
|
if (!dir.cdUp()) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
dir = QDir(QCoreApplication::applicationDirPath());
|
|
for (int i = 0; i < 8; ++i) {
|
|
const QString candidate = dir.absoluteFilePath(QStringLiteral("server"));
|
|
if (QFileInfo::exists(candidate + QStringLiteral("/consumer_server_cli.py"))) {
|
|
return QFileInfo(candidate).absoluteFilePath();
|
|
}
|
|
if (!dir.cdUp()) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return QString();
|
|
}
|
|
|
|
void ServerProcess::parseLogLine(const QString &line) {
|
|
Q_UNUSED(line);
|
|
}
|