juni/crystall-punk-14
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into ed-16-02-2025-planet-light-upstream

Browse Source
This commit is contained in:
Ed
2025-02-16 12:55:34 +03:00
parent 7328f3449c 29029d2586
commit d75b30b2a6
10 changed files with 415 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
Content.Server/Administration/Commands/ChangeCvarCommand.cs Normal file
View File

@@ -0,0 +1,215 @@
using System.Linq;
using Content.Server.Administration.Logs;
using Content.Server.Administration.Managers;
using Content.Shared.Administration;
using Content.Shared.Database;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
namespace Content.Server.Administration.Commands;
/// <summary>
/// Allows admins to change certain CVars. This is different than the "cvar" command which is host only and can change any CVar.
/// </summary>
/// <remarks>
/// Possible todo for future, store default values for cvars, and allow resetting to default.
/// </remarks>
[AnyCommand]
public sealed class ChangeCvarCommand : IConsoleCommand
{
[Dependency] private readonly IConfigurationManager _configurationManager = default!;
[Dependency] private readonly IAdminLogManager _adminLogManager = default!;
[Dependency] private readonly CVarControlManager _cVarControlManager = default!;
/// <summary>
/// Searches the list of cvars for a cvar that matches the search string.
/// </summary>
private void SearchCVars(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length < 2)
{
shell.WriteLine(Loc.GetString("cmd-changecvar-search-no-arguments"));
return;
}
var cvars = _cVarControlManager.GetAllRunnableCvars(shell);
var matches = cvars
.Where(c =>
c.Name.Contains(args[1], StringComparison.OrdinalIgnoreCase)
|| c.ShortHelp?.Contains(args[1], StringComparison.OrdinalIgnoreCase) == true
|| c.LongHelp?.Contains(args[1], StringComparison.OrdinalIgnoreCase) == true
) // Might be very slow and stupid, but eh.
.ToList();
if (matches.Count == 0)
{
shell.WriteLine(Loc.GetString("cmd-changecvar-search-no-matches"));
return;
}
shell.WriteLine(Loc.GetString("cmd-changecvar-search-matches", ("count", matches.Count)));
shell.WriteLine(string.Join("\n", matches.Select(FormatCVarFullHelp)));
}
/// <summary>
/// Formats a CVar into a string for display.
/// </summary>
private string FormatCVarFullHelp(ChangableCVar cvar)
{
if (cvar.LongHelp != null && cvar.ShortHelp != null)
{
return $"{cvar.Name} - {cvar.LongHelp}";
}
// There is no help, no one is coming. We are all doomed.
return cvar.Name;
}
public string Command => "changecvar";
public string Description { get; } = Loc.GetString("cmd-changecvar-desc");
public string Help { get; } = Loc.GetString("cmd-changecvar-help");
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
if (args.Length == 0)
{
shell.WriteLine(Loc.GetString("cmd-changecvar-no-arguments"));
return;
}
var cvars = _cVarControlManager.GetAllRunnableCvars(shell);
var cvar = args[0];
if (cvar == "?")
{
if (cvars.Count == 0)
{
shell.WriteLine(Loc.GetString("cmd-changecvar-no-cvars"));
return;
}
shell.WriteLine(Loc.GetString("cmd-changecvar-available-cvars"));
shell.WriteLine(string.Join("\n", cvars.Select(FormatCVarFullHelp)));
return;
}
if (cvar == "search")
{
SearchCVars(shell, argStr, args);
return;
}
if (!_configurationManager.IsCVarRegistered(cvar)) // Might be a redunat check with the if statement below.
{
shell.WriteLine(Loc.GetString("cmd-changecvar-cvar-not-registered", ("cvar", cvar)));
return;
}
if (cvars.All(c => c.Name != cvar))
{
shell.WriteLine(Loc.GetString("cmd-changecvar-cvar-not-allowed"));
return;
}
if (args.Length == 1)
{
var value = _configurationManager.GetCVar<object>(cvar);
shell.WriteLine(value.ToString()!);
}
else
{
var value = args[1];
var type = _configurationManager.GetCVarType(cvar);
try
{
var parsed = CVarCommandUtil.ParseObject(type, value);
// Value check, is it in the min/max range?
var control = _cVarControlManager.GetCVar(cvar)!.Control; // Null check is done above.
var allowed = true;
if (control is { Min: not null, Max: not null })
{
switch (parsed) // This looks bad, and im not sorry.
{
case int intVal:
{
if (intVal < (int)control.Min || intVal > (int)control.Max)
{
allowed = false;
}
break;
}
case float floatVal:
{
if (floatVal < (float)control.Min || floatVal > (float)control.Max)
{
allowed = false;
}
break;
}
case long longVal:
{
if (longVal < (long)control.Min || longVal > (long)control.Max)
{
allowed = false;
}
break;
}
case ushort ushortVal:
{
if (ushortVal < (ushort)control.Min || ushortVal > (ushort)control.Max)
{
allowed = false;
}
break;
}
}
}
if (!allowed)
{
shell.WriteError(Loc.GetString("cmd-changecvar-value-out-of-range",
("min", control.Min ?? "-∞"),
("max", control.Max ?? "∞")));
return;
}
var oldValue = _configurationManager.GetCVar<object>(cvar);
_configurationManager.SetCVar(cvar, parsed);
_adminLogManager.Add(LogType.AdminCommands,
LogImpact.High,
$"{shell.Player!.Name} ({shell.Player!.UserId}) changed CVAR {cvar} from {oldValue.ToString()} to {parsed.ToString()}"
);
shell.WriteLine(Loc.GetString("cmd-changecvar-success", ("cvar", cvar), ("old", oldValue), ("value", parsed)));
}
catch (FormatException)
{
shell.WriteError(Loc.GetString("cmd-cvar-parse-error", ("type", type)));
}
}
}
public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
{
var cvars = _cVarControlManager.GetAllRunnableCvars(shell);
if (args.Length == 1)
{
return CompletionResult.FromHintOptions(
cvars
.Select(c => new CompletionOption(c.Name, c.ShortHelp ?? c.Name)),
Loc.GetString("cmd-changecvar-arg-name"));
}
var cvar = args[0];
if (!_configurationManager.IsCVarRegistered(cvar))
return CompletionResult.Empty;
var type = _configurationManager.GetCVarType(cvar);
return CompletionResult.FromHint($"<{type.Name}>");
}
}

125
Content.Server/Administration/Managers/CVarControlManager.cs Normal file
View File

@@ -0,0 +1,125 @@
using System.Linq;
using System.Reflection;
using Content.Shared.CCVar.CVarAccess;
using Robust.Shared.Configuration;
using Robust.Shared.Console;
using Robust.Shared.Player;
using Robust.Shared.Reflection;
namespace Content.Server.Administration.Managers;
/// <summary>
/// Manages the control of CVars via the <see cref="Content.Shared.CCVar.CVarAccess.CVarControl"/> attribute.
/// </summary>
public sealed class CVarControlManager : IPostInjectInit
{
[Dependency] private readonly IReflectionManager _reflectionManager = default!;
[Dependency] private readonly IAdminManager _adminManager = default!;
[Dependency] private readonly ILocalizationManager _localizationManager = default!;
[Dependency] private readonly ILogManager _logger = default!;
private readonly List<ChangableCVar> _changableCvars = new();
private ISawmill _sawmill = default!;
void IPostInjectInit.PostInject()
{
_sawmill = _logger.GetSawmill("cvarcontrol");
}
public void Initialize()
{
RegisterCVars();
}
private void RegisterCVars()
{
if (_changableCvars.Count != 0)
{
_sawmill.Warning("CVars already registered, overwriting.");
_changableCvars.Clear();
}
var validCvarsDefs = _reflectionManager.FindTypesWithAttribute<CVarDefsAttribute>();
foreach (var type in validCvarsDefs)
{
foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy))
{
var allowed = field.GetCustomAttribute<CVarControl>();
if (allowed == null)
{
continue;
}
var cvarDef = (CVarDef)field.GetValue(null)!;
_changableCvars.Add(new ChangableCVar(cvarDef.Name, allowed, _localizationManager));
}
}
_sawmill.Info($"Registered {_changableCvars.Count} CVars.");
}
/// <summary>
/// Gets all CVars that the player can change.
/// </summary>
public List<ChangableCVar> GetAllRunnableCvars(IConsoleShell shell)
{
// Not a player, running as server. We COULD return all cvars,
// but a check later down the line will prevent it from anyways. Use the "cvar" command instead.
if (shell.Player == null)
return [];
return GetAllRunnableCvars(shell.Player);
}
public List<ChangableCVar> GetAllRunnableCvars(ICommonSession session)
{
var adminData = _adminManager.GetAdminData(session);
if (adminData == null)
return []; // Not an admin
return _changableCvars
.Where(cvar => adminData.HasFlag(cvar.Control.AdminFlags))
.ToList();
}
public ChangableCVar? GetCVar(string name)
{
return _changableCvars.FirstOrDefault(cvar => cvar.Name == name);
}
}
public sealed class ChangableCVar
{
private const string LocPrefix = "changecvar";
public string Name { get; }
// Holding a reference to the attribute might be skrunkly? Not sure how much mem it eats up.
public CVarControl Control { get; }
public string? ShortHelp;
public string? LongHelp;
public ChangableCVar(string name, CVarControl control, ILocalizationManager loc)
{
Name = name;
Control = control;
if (loc.TryGetString($"{LocPrefix}-simple-{name.Replace('.', '_')}", out var simple))
{
ShortHelp = simple;
}
if (loc.TryGetString($"{LocPrefix}-full-{name.Replace('.', '_')}", out var longHelp))
{
LongHelp = longHelp;
}
// If one is set and the other is not, we throw
if (ShortHelp == null && LongHelp != null || ShortHelp != null && LongHelp == null)
{
throw new InvalidOperationException("Short and long help must both be set or both be null.");
}
}
}

1
Content.Server/Entry/EntryPoint.cs
View File

@@ -160,6 +160,7 @@ namespace Content.Server.Entry
IoCManager.Resolve<IBanManager>().Initialize();
IoCManager.Resolve<IConnectionManager>().PostInit();
IoCManager.Resolve<MultiServerKickManager>().Initialize();
IoCManager.Resolve<CVarControlManager>().Initialize();
}
}

1
Content.Server/IoC/ServerContentIoC.cs
View File

@@ -82,6 +82,7 @@ namespace Content.Server.IoC
IoCManager.Register<IWatchlistWebhookManager, WatchlistWebhookManager>();
IoCManager.Register<ConnectionManager>();
IoCManager.Register<MultiServerKickManager>();
IoCManager.Register<CVarControlManager>();
}
}
}