Files
2026-02-09 08:32:09 -05:00

249 lines
8.3 KiB
C#

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using DataServer.Data;
using Server.Redis;
using System.Text.Json;
using GameServer.Dungeon;
namespace GameServices.Admin.Pages.Server;
public class IndexModel : AdminPageModel
{
private readonly GameDbContext _db;
private readonly IRedisManager _redis;
private readonly DungeonHandler? _dungeonHandler;
private readonly ILogger<IndexModel> _logger;
private static readonly List<BroadcastRecord> _recentBroadcasts = new();
private static readonly object _lock = new();
public IndexModel(GameDbContext db, IRedisManager redis, ILogger<IndexModel> logger, DungeonHandler? dungeonHandler = null)
{
_db = db;
_redis = redis;
_logger = logger;
_dungeonHandler = dungeonHandler;
}
public int ActiveConnections { get; set; }
public int ActiveDungeons { get; set; }
public int TotalAccounts { get; set; }
public int TotalCharacters { get; set; }
public int TrackedAssets { get; set; }
public List<BroadcastRecord> RecentBroadcasts { get; set; } = new();
public bool SpatialFilterEnabled { get; set; } = true;
public float SpatialRadiusPx { get; set; } = 896f;
public int SpatialIntervalTicks { get; set; } = 1;
[TempData]
public string? Message { get; set; }
[TempData]
public bool IsError { get; set; }
public async Task OnGetAsync()
{
// Get stats from Redis
try
{
var playerCount = await _redis.Db.StringGetAsync("stats:players");
if (playerCount.HasValue && int.TryParse(playerCount, out var pc))
ActiveConnections = pc;
var dungeonCount = await _redis.Db.StringGetAsync("stats:dungeons");
if (dungeonCount.HasValue && int.TryParse(dungeonCount, out var dc))
ActiveDungeons = dc;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Failed to get stats from Redis");
}
TotalAccounts = await _db.Accounts.CountAsync();
TotalCharacters = await _db.DungeonCharacters.CountAsync(c => !c.IsDeleted);
TrackedAssets = await _db.ClientAssets.CountAsync();
lock (_lock)
{
RecentBroadcasts = _recentBroadcasts.OrderByDescending(b => b.SentAt).Take(10).ToList();
}
if (_dungeonHandler != null)
{
var tuning = _dungeonHandler.GetSpatialUpdateTuning();
SpatialFilterEnabled = tuning.enabled;
SpatialRadiusPx = tuning.radiusPx;
SpatialIntervalTicks = tuning.intervalTicks;
}
}
public IActionResult OnPostUpdateSpatialAsync(bool spatialFilterEnabled, float spatialRadiusPx, int spatialIntervalTicks)
{
if (_dungeonHandler == null)
{
Message = "DungeonHandler is not available on this pod.";
IsError = true;
return RedirectToPage();
}
try
{
_dungeonHandler.SetSpatialFilterEnabled(spatialFilterEnabled);
_dungeonHandler.SetSpatialUpdateRangePx(spatialRadiusPx);
_dungeonHandler.SetSpatialUpdateIntervalTicks(spatialIntervalTicks);
var updated = _dungeonHandler.GetSpatialUpdateTuning();
Message = $"Spatial tuning updated: enabled={updated.enabled}, radius={updated.radiusPx:0}px, interval={updated.intervalTicks} tick(s)";
IsError = false;
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to update spatial tuning");
Message = $"Failed to update spatial tuning: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostBroadcastAsync(string message, string messageType)
{
if (string.IsNullOrWhiteSpace(message))
{
Message = "Message cannot be empty.";
IsError = true;
return RedirectToPage();
}
try
{
// Publish to Redis for all pods to pick up
var payload = JsonSerializer.Serialize(new
{
type = messageType ?? "system",
message = message,
duration = 10,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord(message, messageType ?? "system", DateTime.UtcNow));
while (_recentBroadcasts.Count > 50)
_recentBroadcasts.RemoveAt(0);
}
Message = $"Broadcast sent ({messageType}): {message}";
_logger.LogInformation("Admin broadcast sent: [{Type}] {Message}", messageType, message);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send broadcast");
Message = $"Failed to send broadcast: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostRefreshAssetsAsync()
{
try
{
var commandPayload = JsonSerializer.Serialize(new
{
command = "refresh_assets",
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:command", commandPayload);
var broadcastPayload = JsonSerializer.Serialize(new
{
type = "info",
message = "Asset update available. Your client will refresh automatically.",
duration = 10,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", broadcastPayload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Asset refresh signal sent", "system", DateTime.UtcNow));
}
Message = "Asset refresh signal sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send asset refresh");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostMaintenanceWarningAsync()
{
try
{
var payload = JsonSerializer.Serialize(new
{
type = "announcement",
message = "⚠️ Server maintenance in 5 minutes. Please finish your current activities.",
duration = 30,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Maintenance warning (5 min)", "announcement", DateTime.UtcNow));
}
Message = "Maintenance warning sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send maintenance warning");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public async Task<IActionResult> OnPostServerRestartAsync()
{
try
{
var payload = JsonSerializer.Serialize(new
{
type = "alert",
message = "🔄 Server restart imminent. Please save your progress and return to hub.",
duration = 30,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
await _redis.Bus.PublishAsync("server:broadcast", payload);
lock (_lock)
{
_recentBroadcasts.Add(new BroadcastRecord("Server restart warning", "alert", DateTime.UtcNow));
}
Message = "Server restart warning sent to all pods.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to send restart warning");
Message = $"Failed: {ex.Message}";
IsError = true;
}
return RedirectToPage();
}
public record BroadcastRecord(string Message, string Type, DateTime SentAt);
}