zio fork 1.8.2b-zio16: backport unban, rename and css_history from upstream 1.9.0

From upstream 530f603:
- css_unban updates the ban cache at once (and clears the engine banid with
  UnlockedCommands) instead of waiting up to a minute for the cache refresh.
- css_prename is saved in sa_renames (migration 017) and re-applied on connect and
  name change, so it survives restarts. css_rename from a hidden admin renames again.
- New css_history command and Players > History menu entry. Commands missing from an
  existing Commands.json are registered under their default name.
- Migrations are copied with a glob, so 017 reaches the build output.

Upstream's admin-loading changes, css_say change and css_penalties fix are left out.

CS2-SimpleAdmin/Managers/BanManager.cs

@@ -1,5 +1,6 @@
 using CounterStrikeSharp.API;
 using CounterStrikeSharp.API.ValveConstants.Protobuf;
+using CounterStrikeSharp.API.Modules.Entities;
 using CS2_SimpleAdminApi;
 using Dapper;
 using Microsoft.Extensions.Logging;
@@ -339,8 +340,34 @@ public async Task UnbanPlayer(string playerPattern, string adminSteamId, string
             var sqlUpdateBan = databaseProvider.GetUpdateBanStatusQuery();
             await connection.ExecuteAsync(sqlUpdateBan, new { unbanId, banId });
         }
+
+        // Apply immediately; the periodic cache refresh would otherwise keep rejecting the player for up to a minute
+        CS2_SimpleAdmin.Instance.CacheManager?.SetBanStatus(bansList.Select(b => (int)b.id), Models.BanStatus.UNBANNED);
+
+        // css_ban also issues a native banid when UnlockedCommands is on; clear it so the engine stops
+        // rejecting the player. Done here, after the rows are updated, and for whichever pattern matched them.
+        if (CS2_SimpleAdmin.UnlockedCommands)
+        {
+            var steamIds = bansList
+                .Select(b => (object?)b.player_steamid)
+                .Where(id => id != null)
+                .Select(id => Convert.ToUInt64(id))
+                .Where(id => id > 0)
+                .Distinct()
+                .ToList();
+
+            if (steamIds.Count > 0)
+                await Server.NextWorldUpdateAsync(() =>
+                {
+                    foreach (var steamId in steamIds)
+                        Server.ExecuteCommand($"removeid {new SteamID(steamId).SteamId3}");
+                });
+        }
+    }
+    catch (Exception ex)
+    {
+        CS2_SimpleAdmin._logger?.LogError("Unable to unban player: {exception}", ex.Message);
     }
-    catch { }
 }
 
     // public async Task CheckOnlinePlayers(List<(string? IpAddress, ulong SteamID, int? UserId, int Slot)> players)

CS2-SimpleAdmin/Managers/CacheManager.cs

@@ -10,8 +10,10 @@ namespace CS2_SimpleAdmin.Managers;
 internal class CacheManager: IDisposable
 {
     private readonly ConcurrentDictionary<int, BanRecord> _banCache = [];
-    private readonly ConcurrentDictionary<ulong, List<BanRecord>> _steamIdIndex = [];
-    private readonly ConcurrentDictionary<uint, List<BanRecord>> _ipIndex = [];
+    // Rebuilt into fresh instances and swapped, so unlocked readers on the game thread never see a half-built index
+    private ConcurrentDictionary<ulong, List<BanRecord>> _steamIdIndex = [];
+    private ConcurrentDictionary<uint, List<BanRecord>> _ipIndex = [];
+    private readonly object _indexLock = new();
 
     private readonly ConcurrentDictionary<ulong, HashSet<IpRecord>> _playerIpsCache = [];
     private HashSet<uint> _cachedIgnoredIps = [];
@@ -178,7 +180,7 @@ internal class CacheManager: IDisposable
                     player_steamid AS PlayerSteamId,
                     player_ip AS PlayerIp,
                     status AS Status
-                    FROM `sa_bans` WHERE updated_at > @lastUpdate OR created > @lastUpdate ORDER BY updated_at DESC
+                    FROM `sa_bans` WHERE updated_at >= @lastUpdate OR created >= @lastUpdate ORDER BY updated_at DESC
                     """,
                     new { lastUpdate = lastCheckTime }
                 )).ToList();
@@ -221,7 +223,7 @@ internal class CacheManager: IDisposable
                     player_steamid AS PlayerSteamId,
                     player_ip AS PlayerIp,
                     status AS Status
-                    FROM `sa_bans` WHERE server_id = @serverId AND (updated_at > @lastUpdate OR created > @lastUpdate) ORDER BY updated_at DESC
+                    FROM `sa_bans` WHERE server_id = @serverId AND (updated_at >= @lastUpdate OR created >= @lastUpdate) ORDER BY updated_at DESC
                     """,
                     new { serverId = CS2_SimpleAdmin.ServerId, lastUpdate = lastCheckTime }
                 )).ToList();
@@ -294,7 +296,7 @@ internal class CacheManager: IDisposable
                             .GroupBy(x => x.Address)
                             .Select(g =>
                             {
-                                var latest = g.MaxBy(x => x.Used_at);
+                                var latest = g.MaxBy(x => x.Used_at)!; // group is never empty
                                 return new IpRecord(
                                     g.Key,
                                     latest.Used_at,
@@ -353,8 +355,36 @@ internal class CacheManager: IDisposable
     /// </summary>
     private void RebuildIndexes()
     {
-        _steamIdIndex.Clear();
-        _ipIndex.Clear();
+        // SetBanStatus (unban thread) and RefreshCacheAsync (timer thread) can both get here
+        lock (_indexLock)
+        {
+            RebuildIndexesCore();
+        }
+    }
+
+    /// <summary>
+    /// Updates the status of the given bans in the cache and rebuilds the indexes,
+    /// so unbans take effect immediately instead of waiting for the next refresh.
+    /// </summary>
+    /// <param name="banIds">Ban ids to update.</param>
+    /// <param name="status">New status.</param>
+    public void SetBanStatus(IEnumerable<int> banIds, BanStatus status)
+    {
+        var changed = false;
+        foreach (var id in banIds)
+        {
+            if (!_banCache.TryGetValue(id, out var ban) || ban.StatusEnum == status) continue;
+            _banCache[id] = ban with { Status = status.ToString() };
+            changed = true;
+        }
+
+        if (changed) RebuildIndexes();
+    }
+
+    private void RebuildIndexesCore()
+    {
+        var steamIdIndex = new ConcurrentDictionary<ulong, List<BanRecord>>();
+        var ipIndex = new ConcurrentDictionary<uint, List<BanRecord>>();
 
         // Optimization: Cache config value to avoid repeated property access
         var banType = CS2_SimpleAdmin.Instance.Config.OtherSettings.BanType;
@@ -369,10 +399,10 @@ internal class CacheManager: IDisposable
             if (ban.PlayerSteamId.HasValue)
             {
                 var steamId = ban.PlayerSteamId.Value;
-                if (!_steamIdIndex.TryGetValue(steamId, out var steamList))
+                if (!steamIdIndex.TryGetValue(steamId, out var steamList))
                 {
                     steamList = new List<BanRecord>();
-                    _steamIdIndex[steamId] = steamList;
+                    steamIdIndex[steamId] = steamList;
                 }
                 steamList.Add(ban);
             }
@@ -381,14 +411,18 @@ internal class CacheManager: IDisposable
             if (checkIpBans && !string.IsNullOrEmpty(ban.PlayerIp) &&
                 IpHelper.TryConvertIpToUint(ban.PlayerIp, out var ipUInt))
             {
-                if (!_ipIndex.TryGetValue(ipUInt, out var ipList))
+                if (!ipIndex.TryGetValue(ipUInt, out var ipList))
                 {
                     ipList = new List<BanRecord>();
-                    _ipIndex[ipUInt] = ipList;
+                    ipIndex[ipUInt] = ipList;
                 }
                 ipList.Add(ban);
             }
         }
+
+        // Reference swap is atomic; readers finish on the old index or start on the complete new one
+        Volatile.Write(ref _steamIdIndex, steamIdIndex);
+        Volatile.Write(ref _ipIndex, ipIndex);
     }
     
     /// <summary>

CS2-SimpleAdmin/Managers/PlayerManager.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using CounterStrikeSharp.API;
 using CounterStrikeSharp.API.Core;
 using CounterStrikeSharp.API.Modules.Admin;
@@ -92,6 +93,11 @@ internal class PlayerManager
         // zio: read on the main thread; the ban check below runs on a worker thread.
         var bypassIpBans = AdminManager.PlayerHasPermissions(new SteamID(steamId), IpBanBypassPermission);
 
+        if (CS2_SimpleAdmin.RenamedPlayers.TryGetValue(steamId, out var renamedTo))
+        {
+            player.Rename(renamedTo);
+        }
+
         if (CS2_SimpleAdmin.DatabaseProvider == null || CS2_SimpleAdmin.Instance.CacheManager == null) return;
 
         Task.Run(async () =>
@@ -297,10 +303,92 @@ internal class PlayerManager
                 _loadPlayerSemaphore.Release();
             }
         });
+    }
 
-        if (CS2_SimpleAdmin.RenamedPlayers.TryGetValue(player.SteamID, out var name))
+    /// <summary>
+    /// Returns every ban, gag/mute/silence and warn ever recorded for a SteamID, newest first.
+    /// Rows carry: type, status, reason, duration, created, ends, admin_name, lift_reason, lift_date, lift_admin.
+    /// </summary>
+    /// <param name="steamId">SteamID64 of the player, online or not.</param>
+    /// <param name="type">Optional filter: bans, gags, mutes, silences or warns.</param>
+    public async Task<List<dynamic>> GetPenaltyHistory(ulong steamId, string? type = null)
+    {
+        if (CS2_SimpleAdmin.DatabaseProvider == null) return [];
+
+        try
         {
-            player.Rename(name);
+            await using var connection = await CS2_SimpleAdmin.DatabaseProvider.CreateConnectionAsync();
+            var sql = CS2_SimpleAdmin.DatabaseProvider.GetPenaltyHistoryQuery(CS2_SimpleAdmin.Instance.Config.MultiServerMode);
+            var rows = (await connection.QueryAsync(sql, new { PlayerSteamID = steamId, serverid = CS2_SimpleAdmin.ServerId })).ToList();
+
+            // Filter word is the plural (bans, gags, mutes, silences, warns); rows carry BAN/GAG/MUTE/SILENCE/WARN
+            if (type != null)
+                rows.RemoveAll(r => !type.Equals((string)r.type + "s", StringComparison.OrdinalIgnoreCase));
+
+            return rows;
+        }
+        catch (Exception ex)
+        {
+            CS2_SimpleAdmin._logger?.LogError("Unable to load penalty history: {exception}", ex.Message);
+            return [];
+        }
+    }
+
+    /// <summary>
+    /// Dapper gives DateTime on MySQL but can give a string on SQLite; accept both.
+    /// </summary>
+    internal static DateTime? ToDateTime(object? value) =>
+        value switch
+        {
+            DateTime d => d,
+            string s when DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed) => parsed,
+            _ => null
+        };
+
+    /// <summary>
+    /// Loads permanent renames from the database into memory.
+    /// </summary>
+    public async Task LoadRenamedPlayers()
+    {
+        if (CS2_SimpleAdmin.DatabaseProvider == null) return;
+
+        try
+        {
+            await using var connection = await CS2_SimpleAdmin.DatabaseProvider.CreateConnectionAsync();
+            var rows = await connection.QueryAsync<(long steamId, string name)>(CS2_SimpleAdmin.DatabaseProvider.GetRenamesQuery());
+
+            await Server.NextWorldUpdateAsync(() =>
+            {
+                foreach (var (steamId, name) in rows)
+                    CS2_SimpleAdmin.RenamedPlayers[(ulong)steamId] = name;
+            });
+        }
+        catch (Exception ex)
+        {
+            CS2_SimpleAdmin._logger?.LogError("Unable to load renames: {exception}", ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// Persists or removes a permanent rename (css_prename) for a player.
+    /// </summary>
+    /// <param name="steamId">SteamID64 of the player.</param>
+    /// <param name="name">Forced name, or null/empty to remove the rename.</param>
+    public async Task SaveRenamedPlayer(ulong steamId, string? name)
+    {
+        if (CS2_SimpleAdmin.DatabaseProvider == null) return;
+
+        try
+        {
+            await using var connection = await CS2_SimpleAdmin.DatabaseProvider.CreateConnectionAsync();
+            if (string.IsNullOrEmpty(name))
+                await connection.ExecuteAsync(CS2_SimpleAdmin.DatabaseProvider.GetDeleteRenameQuery(), new { steamId });
+            else
+                await connection.ExecuteAsync(CS2_SimpleAdmin.DatabaseProvider.GetUpsertRenameQuery(), new { steamId, name });
+        }
+        catch (Exception ex)
+        {
+            CS2_SimpleAdmin._logger?.LogError("Unable to save rename: {exception}", ex.Message);
         }
     }
 

CS2-SimpleAdmin/Managers/ServerManager.cs

@@ -43,6 +43,7 @@ public class ServerManager
             if (_getIpTryCount > 32 && isInvalidIp)
             {
                 CS2_SimpleAdmin._logger?.LogError("Unable to load server data - can't fetch ip address!");
+                _ = CS2_SimpleAdmin.PlayerManager.LoadRenamedPlayers();
                 return;
             }
 
@@ -103,7 +104,7 @@ public class ServerManager
                     CS2_SimpleAdmin.ServerId = serverId;
                     CS2_SimpleAdmin._logger?.LogInformation("Loaded server with ip {ip}", ipAddress);
 
-CS2_SimpleAdmin.ServerLoaded = true;
+                    CS2_SimpleAdmin.ServerLoaded = true;
 
                     if (CS2_SimpleAdmin.Instance.CacheManager != null)
                     {
@@ -115,6 +116,9 @@ CS2_SimpleAdmin.ServerLoaded = true;
                     CS2_SimpleAdmin._logger?.LogCritical("Unable to create or get server_id: " + ex.Message);
                 }
 
+                // Renames are server-independent, so load them even when the server row could not be resolved
+                await CS2_SimpleAdmin.PlayerManager.LoadRenamedPlayers();
+
                 if (CS2_SimpleAdmin.Instance.Config.EnableMetrics)
                 {
                     var queryString = $"?address={address}&hostname={hostname}";