Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-10-02 10:53:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e213a7aeff01bfd0c274b245cdd2bdc7bf95dabb
DarkflameServer/dDashboardServer/routes/LiveWorld.cpp
Aaron Kimbrell e213a7aeff feat: web dashboard and playground work 
The NexusDashboard-parity dashboard (dDashboardServer) and everything built on it on the experimental branch:
accounts, characters, properties and moderation tools, permissions shared with in-game slash commands, economy
reports, World 3D and property 3D views with client scenery, scheduled events (features, vanity changes, live
events, announcements, restarts), vanity files and events, the CDClient browser, the message inspector with saved
captures, chat filter tools, community challenges, live ops, the AI moderator helper, and the server-side changes
they need.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-28 22:30:43 -05:00

321 lines
14 KiB
C++
Raw Blame History

#include "LiveWorld.h"
#include "WorldView.h"
#include "Permissions.h"
#include "DashboardRoutes.h"
#include <chrono>
#include <ctime>
#include <map>
#include "RouteUtils.h"
#include "Alerts.h"
#include "BitStreamUtils.h"
#include "ServerState.h"
#include "DashboardMessages.h"
#include "Database.h"
#include "Game.h"
#include "Logger.h"
#include "MessageType/Master.h"
#include "ServiceType.h"
#include "Web.h"
#include "dServer.h"
#include "eHTTPMethod.h"
using namespace RouteUtils;
namespace {
using Clock = std::chrono::steady_clock;
constexpr auto PUSH_INTERVAL = std::chrono::milliseconds(500);
constexpr auto STALE_AFTER = std::chrono::seconds(20);
constexpr const char* RESTART_STATE = "scheduled_restart";
// Warnings before a scheduled restart, in seconds; only those shorter than the notice given are sent
constexpr int64_t WARNINGS[] = { 3600, 1800, 900, 600, 300, 120, 60, 30, 10 };
struct WorldPlayers {
PlayerPositions positions;
Clock::time_point received;
};
std::map<std::pair<uint32_t, uint32_t>, WorldPlayers> g_Worlds; // by (zone, instance)
std::map<LWOOBJID, std::string> g_Names;
bool g_PositionsChanged = false;
Clock::time_point g_NextPush{};
struct Restart {
int64_t at{};
std::string reason;
std::string by;
int64_t lastWarning{}; // seconds-before of the last warning sent
};
std::optional<Restart> g_Restart;
bool g_RestartLoaded = false;
std::string CharacterName(LWOOBJID id) {
const auto it = g_Names.find(id);
if (it != g_Names.end()) return it->second;
const auto info = Database::Get()->GetCharacterInfo(id);
return g_Names[id] = info ? info->name : std::to_string(id);
}
nlohmann::json PlayersJson() {
nlohmann::json players = nlohmann::json::array();
for (const auto& [key, world] : g_Worlds) {
for (const auto& player : world.positions.players) {
players.push_back({
{"id", std::to_string(player.characterId)}, {"name", CharacterName(player.characterId)},
{"zone", world.positions.zoneId}, {"instance", world.positions.instanceId}, {"clone", world.positions.cloneId},
{"x", player.x}, {"y", player.y}, {"z", player.z}
});
}
}
return players;
}
void SendAnnouncement(const std::string& title, const std::string& message, const std::vector<uint32_t>& zones = {}) {
if (!Game::server || !Game::server->GetIsConnectedToMaster()) return;
Announcement announcement{ title, message, zones };
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::ANNOUNCE);
announcement.Serialize(bitStream);
Game::server->SendToMaster(bitStream);
}
std::string Duration(int64_t seconds) {
if (seconds >= 3600 && seconds % 3600 == 0) return std::to_string(seconds / 3600) + (seconds == 3600 ? " hour" : " hours");
if (seconds >= 60) {
const auto minutes = (seconds + 30) / 60;
return std::to_string(minutes) + (minutes == 1 ? " minute" : " minutes");
}
return std::to_string(seconds) + " seconds";
}
void SaveRestart() {
if (g_Restart) {
Database::Get()->SetDashboardState(RESTART_STATE, nlohmann::json{
{"at", g_Restart->at}, {"reason", g_Restart->reason}, {"by", g_Restart->by}, {"lastWarning", g_Restart->lastWarning}
}.dump());
} else {
Database::Get()->DeleteDashboardState(RESTART_STATE);
}
}
void LoadRestart() {
g_RestartLoaded = true;
const auto stored = Database::Get()->GetDashboardState(RESTART_STATE);
if (!stored) return;
const auto json = nlohmann::json::parse(*stored, nullptr, false);
if (json.is_discarded()) return;
g_Restart = Restart{ json.value("at", int64_t{ 0 }), json.value("reason", ""), json.value("by", ""), json.value("lastWarning", int64_t{ 0 }) };
// A restart that was due while the dashboard was down is dropped rather than run by surprise
if (g_Restart->at < std::time(nullptr)) {
LOG("Dropping a scheduled restart that was due while the dashboard was offline");
g_Restart.reset();
SaveRestart();
}
}
std::string RestartMessage(int64_t secondsLeft) {
std::string message = "The server restarts in " + Duration(secondsLeft) + ".";
if (!g_Restart->reason.empty()) message += " " + g_Restart->reason;
return message;
}
void TickRestart() {
if (!g_RestartLoaded) LoadRestart();
if (!g_Restart) return;
const auto left = g_Restart->at - static_cast<int64_t>(std::time(nullptr));
if (left <= 0) {
LOG("Scheduled restart: shutting the server down now");
SendAnnouncement("Server restarting", "The server is restarting now. Please log back in in a few minutes.");
g_Restart.reset();
SaveRestart();
if (Game::server && Game::server->GetIsConnectedToMaster()) {
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::DASHBOARD_SHUTDOWN);
Game::server->SendToMaster(bitStream);
}
return;
}
for (const auto warning : WARNINGS) {
if (left > warning) continue;
// The largest threshold we are inside of, sent once
if (g_Restart->lastWarning == 0 || warning < g_Restart->lastWarning) {
g_Restart->lastWarning = warning;
SaveRestart();
SendAnnouncement("Server restart", RestartMessage(left));
}
break;
}
}
}
namespace LiveWorld {
std::optional<std::string> ScheduleRestart(int64_t minutes, const std::string& reason, const HTTPContext& actor, bool replace) {
if (minutes < 1 || minutes > 1440) return "Pick between 1 minute and 24 hours";
if (reason.size() > 300) return "The reason can be at most 300 characters";
if (!g_RestartLoaded) LoadRestart();
if (g_Restart && !replace) return "A restart is already scheduled (by " + g_Restart->by + ")";
g_Restart = Restart{ static_cast<int64_t>(std::time(nullptr)) + minutes * 60, reason, actor.authenticatedUser, 0 };
SaveRestart();
g_NextPush = {}; // send the first warning right away
Audit(actor, "schedule_restart", "In " + Duration(minutes * 60) + (reason.empty() ? "" : ": " + reason));
Alerts::Emit("server", "Restart scheduled", "The server restarts in " + Duration(minutes * 60) + ".",
{ { "By", actor.authenticatedUser }, { "Reason", reason } }, "/");
return std::nullopt;
}
void HandlePlayerPositions(const PlayerPositions& positions) {
const std::pair key{ positions.zoneId, positions.instanceId };
if (positions.players.empty()) g_Worlds.erase(key);
else g_Worlds[key] = { positions, Clock::now() };
g_PositionsChanged = true;
WorldView::RecordPositions(positions);
}
void Update() {
const auto now = Clock::now();
if (now < g_NextPush) return;
g_NextPush = now + PUSH_INTERVAL;
try {
TickRestart();
} catch (const std::exception& ex) {
LOG("Scheduled restart check failed: %s", ex.what());
}
// Worlds that crashed stop reporting; forget them after a while
const auto before = g_Worlds.size();
std::erase_if(g_Worlds, [now](const auto& entry) { return now - entry.second.received > STALE_AFTER; });
if (g_Worlds.size() != before) g_PositionsChanged = true;
if (!g_PositionsChanged) return;
g_PositionsChanged = false;
nlohmann::json message{ {"players", PlayersJson()} };
Game::web.SendWSMessage("player_positions", message);
}
nlohmann::json OnlinePlayers() {
return PlayersJson();
}
bool Announce(const std::string& title, const std::string& message, const std::vector<uint32_t>& zones) {
if (!Game::server || !Game::server->GetIsConnectedToMaster()) return false;
SendAnnouncement(title, message, zones);
return true;
}
nlohmann::json RestartStatus(bool withStaffName) {
if (!g_Restart) return nlohmann::json::object();
nlohmann::json status{ {"at", g_Restart->at}, {"reason", g_Restart->reason} };
if (withStaffName) status["by"] = g_Restart->by;
return status;
}
void RegisterRoutes() {
Game::web.RegisterWSSubscription("player_positions", std::function<uint8_t()>([] { return Permissions::Level("players_view"); }));
Route(eHTTPMethod::GET, "/api/live/players", Perm("players_view"), "Where online players are right now (also pushed on the player_positions socket topic)",
[](HTTPReply& reply, const HTTPContext&) {
JsonReply(reply, eHTTPStatusCode::OK, { {"players", PlayersJson()} });
});
Route(eHTTPMethod::POST, "/api/worlds/shutdown", Perm("worlds_manage"),
"Shut down one world instance; its players are saved and disconnected, and a new instance starts when someone goes there. Body: {zone, instance}",
[](HTTPReply& reply, const HTTPContext& context) {
const auto body = ParseBody(context);
if (!body) return JsonError(reply, eHTTPStatusCode::BAD_REQUEST, "Invalid JSON");
const uint32_t zone = body->value("zone", 0u), instance = body->value("instance", 0u);
bool running = false;
uint32_t players = 0;
{
std::lock_guard lock(ServerState::g_StatusMutex);
for (const auto& world : ServerState::g_WorldInstances) {
if (world.mapID == zone && world.instanceID == instance) { running = true; players = world.players; }
}
}
if (!running) return JsonError(reply, eHTTPStatusCode::NOT_FOUND, "That world instance isn't running");
if (!Game::server || !Game::server->GetIsConnectedToMaster()) return JsonError(reply, eHTTPStatusCode::SERVICE_UNAVAILABLE, "Not connected to the master server");
CBITSTREAM;
BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::INSTANCE_SHUTDOWN);
bitStream.Write(zone);
bitStream.Write(instance);
Game::server->SendToMaster(bitStream);
Audit(context, "shutdown_instance", "Zone " + std::to_string(zone) + " instance " + std::to_string(instance) + " (" + std::to_string(players) + " player(s))");
JsonSuccess(reply, { {"message", "Shutting it down"} });
});
Route(eHTTPMethod::GET, "/api/worlds", Perm("players_view"), "Every running world with its instance and clone IDs, address, players and, for property instances, the property and owner",
[](HTTPReply& reply, const HTTPContext&) {
nlohmann::json worlds = nlohmann::json::array();
std::lock_guard lock(ServerState::g_StatusMutex);
for (const auto& w : ServerState::g_WorldInstances) {
worlds.push_back({ {"mapID", w.mapID}, {"zoneName", w.zoneName}, {"instanceID", w.instanceID}, {"cloneID", w.cloneID}, {"players", w.players},
{"isPrivate", w.isPrivate}, {"ip", w.ip}, {"port", w.port}, {"propertyId", w.propertyId}, {"propertyName", w.propertyName},
{"ownerId", w.ownerId}, {"ownerName", w.ownerName} });
}
JsonSuccess(reply, { {"worlds", worlds} });
});
Route(eHTTPMethod::GET, "/api/players/online", Perm("players_view"), "Everyone online: character, account, GM level, world and position",
[](HTTPReply& reply, const HTTPContext&) {
auto players = PlayersJson();
const auto& zones = ZoneNames();
for (auto& player : players) {
const auto zone = std::to_string(player.value("zone", 0));
player["zone_name"] = zones.contains(zone) ? zones[zone].get<std::string>() : "Zone " + zone;
const auto id = GeneralUtils::TryParse<LWOOBJID>(player.value("id", std::string{})).value_or(0);
if (const auto info = Database::Get()->GetCharacterInfo(id)) {
player["account_id"] = info->accountId;
const auto account = Database::Get()->GetAccountById(info->accountId);
player["account_name"] = account.value("name", std::string{});
player["gm_level"] = account.value("gm_level", 0);
}
}
JsonSuccess(reply, { {"players", players} });
});
Route(eHTTPMethod::POST, "/api/server/announce", Perm("server_announce"), "Show an announcement to every player online. Body: {title, message}",
[](HTTPReply& reply, const HTTPContext& context) {
const auto body = ParseBody(context);
if (!body) return JsonError(reply, eHTTPStatusCode::BAD_REQUEST, "Invalid JSON");
const std::string title = body->value("title", "");
const std::string message = body->value("message", "");
if (message.empty() || message.size() > Announcement::MAX_MESSAGE || title.size() > Announcement::MAX_TITLE) {
return JsonError(reply, eHTTPStatusCode::BAD_REQUEST, "Write a message (up to 1000 characters) and a title up to 100");
}
if (!Game::server || !Game::server->GetIsConnectedToMaster()) return JsonError(reply, eHTTPStatusCode::SERVICE_UNAVAILABLE, "Not connected to the master server");
SendAnnouncement(title, message);
Audit(context, "announce", (title.empty() ? "" : title + ": ") + message);
JsonSuccess(reply, { {"message", "Announcement sent"} });
});
Route(eHTTPMethod::GET, "/api/server/restart", Perm("server_restart"), "The scheduled restart, if any, with who scheduled it (everyone gets when and why in /api/status)",
[](HTTPReply& reply, const HTTPContext&) {
JsonReply(reply, eHTTPStatusCode::OK, RestartStatus(true));
});
Route(eHTTPMethod::POST, "/api/server/restart", Perm("server_restart"), "Schedule a restart with in-game warnings. Body: {minutes (1-1440), reason}. Needs a process supervisor to start the server again",
[](HTTPReply& reply, const HTTPContext& context) {
const auto body = ParseBody(context);
if (!body) return JsonError(reply, eHTTPStatusCode::BAD_REQUEST, "Invalid JSON");
const auto minutes = body->value("minutes", 0);
const std::string reason = body->value("reason", "");
if (const auto error = LiveWorld::ScheduleRestart(minutes, reason, context, true)) return JsonError(reply, eHTTPStatusCode::BAD_REQUEST, *error);
JsonSuccess(reply, { {"message", "Restart scheduled"}, {"restart", RestartStatus(true)} });
});
Route(eHTTPMethod::POST, "/api/server/restart/cancel", Perm("server_restart"), "Cancel the scheduled restart",
[](HTTPReply& reply, const HTTPContext& context) {
if (!g_RestartLoaded) LoadRestart();
if (!g_Restart) return JsonError(reply, eHTTPStatusCode::NOT_FOUND, "No restart is scheduled");
const bool warned = g_Restart->lastWarning != 0;
g_Restart.reset();
SaveRestart();
if (warned) SendAnnouncement("Restart cancelled", "The scheduled server restart has been cancelled.");
Audit(context, "cancel_restart", std::string("Cancelled the scheduled server restart") + (warned ? "; players were told" : ""));
Alerts::Emit("server", "Restart cancelled", "The scheduled restart was cancelled.", { { "By", context.authenticatedUser } }, "/");
JsonSuccess(reply, { {"message", "Restart cancelled"} });
});
}
}
Reference in New Issue View Git Blame Copy Permalink