206 lines
6.7 KiB
C#
206 lines
6.7 KiB
C#
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using DataServer.Data;
|
|
using Server.Redis;
|
|
using System.Text.Json;
|
|
|
|
namespace GameServices.Admin.Pages.Server;
|
|
|
|
public class IndexModel : AdminPageModel
|
|
{
|
|
private readonly GameDbContext _db;
|
|
private readonly IRedisManager _redis;
|
|
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)
|
|
{
|
|
_db = db;
|
|
_redis = redis;
|
|
_logger = logger;
|
|
}
|
|
|
|
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();
|
|
|
|
[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();
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|