commands cooldowns using load factors

TPP.Core/Commands/CommandProcessor.cs

@@ -5,16 +5,27 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using NodaTime;
 using TPP.ArgsParsing;
+using TPP.Core.Utils;
+using TPP.Model;
 using TPP.Persistence;
 
 namespace TPP.Core.Commands
 {
+    public interface ICommandProcessor
+    {
+        public Task<CommandResult?> Process(string commandName, IImmutableList<string> args, Message message);
+        public Command? FindCommand(string commandName);
+        public void InstallCommand(Command command);
+        public void UninstallCommand(params string[] commandOrAlias);
+    }
+
     /// <summary>
     /// The command processor can be configured using <see cref="Command"/> instances to have commands,
     /// which then get executed using the <see cref="CommandProcessor.Process"/> method.
     /// </summary>
-    public class CommandProcessor
+    public class CommandProcessor : ICommandProcessor
     {
         /// <summary>
         /// maximum execution time for a command before a warning is logged.
@@ -24,16 +35,45 @@ public class CommandProcessor
         private readonly ILogger<CommandProcessor> _logger;
         private readonly ICommandLogger _commandLogger;
         private readonly ArgsParser _argsParser;
+        private readonly IClock _clock;
+
         private readonly Dictionary<string, Command> _commands = new();
 
+        private readonly float _maxLoadFactor;
+        private readonly Duration _maxLoadFactorTimeframe;
+        private readonly float _additionalLoadFactorAtHighThreshold;
+        private Dictionary<User, TtlQueue<float>> _loadsPerUser = new();
+
+        /// <summary>
+        /// Create a new command processor instance
+        /// </summary>
+        /// <param name="logger">logger</param>
+        /// <param name="commandLogger">command logger</param>
+        /// <param name="argsParser">args parser instance</param>
+        /// <param name="clock">clock</param>
+        /// <param name="maxLoadFactor">maximum load factor before commands are silently dropped</param>
+        /// <param name="maxLoadFactorTimeframe">timeframe for which the load factor is computed</param>
+        /// <param name="additionalLoadFactorAtHighThreshold">
+        /// additional load to add to the load factor when a user is at their maximum load capacity.
+        /// It is linearly interpolated from 0 when there are no messages within the timeframe,
+        /// up to the supplied number multiplier when at the maximum amount of messages within the timeframe.
+        /// This is to have the load factor be more effective against continuous spam than sporadic bursts.</param>
         public CommandProcessor(
             ILogger<CommandProcessor> logger,
             ICommandLogger commandLogger,
-            ArgsParser argsParser)
+            ArgsParser argsParser,
+            IClock clock,
+            float maxLoadFactor = 200f,
+            Duration? maxLoadFactorTimeframe = null,
+            float additionalLoadFactorAtHighThreshold = 2f)
         {
             _logger = logger;
             _commandLogger = commandLogger;
             _argsParser = argsParser;
+            _clock = clock;
+            _maxLoadFactor = maxLoadFactor;
+            _maxLoadFactorTimeframe = maxLoadFactorTimeframe ?? Duration.FromMinutes(10);
+            _additionalLoadFactorAtHighThreshold = additionalLoadFactorAtHighThreshold;
         }
 
         public void InstallCommand(Command command)
@@ -69,8 +109,34 @@ public void UninstallCommand(params string[] commandOrAlias)
         public Command? FindCommand(string commandName) =>
             _commands.TryGetValue(commandName.ToLower(), out Command command) ? command : null;
 
+        private float CheckAndUpdateLoadFactorForUser(User user)
+        {
+            _loadsPerUser = _loadsPerUser
+                .Where(kvp => kvp.Value.Count > 0)
+                .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+            if (!_loadsPerUser.TryGetValue(user, out TtlQueue<float>? loads))
+            {
+                loads = new TtlQueue<float>(_maxLoadFactorTimeframe, _clock);
+                _loadsPerUser[user] = loads;
+            }
+            float sum = loads.Sum();
+            float ratioFilled = Math.Min(1, sum / _maxLoadFactor);
+            float toAdd = 1 + ratioFilled * _additionalLoadFactorAtHighThreshold;
+            loads.Enqueue(toAdd);
+            return sum + toAdd;
+        }
+
         public async Task<CommandResult?> Process(string commandName, IImmutableList<string> args, Message message)
         {
+            float loadFactor = CheckAndUpdateLoadFactorForUser(message.User);
+            if (loadFactor > _maxLoadFactor)
+            {
+                _logger.LogDebug(
+                    "command '{Command}' from user {User} ignored because load factor is {LoadFactor} " +
+                    "for timeframe {Duration}, which is above the maximum of {MaxLoadFactor}",
+                    commandName, message.User, loadFactor, _maxLoadFactorTimeframe, _maxLoadFactor);
+                return new CommandResult();
+            }
             if (!_commands.TryGetValue(commandName.ToLower(), out Command command))
             {
                 _logger.LogDebug("unknown command '{Command}'", commandName);

TPP.Core/Commands/Definitions/HelpCommand.cs

@@ -11,8 +11,8 @@ public class HelpCommand
             Description = "Get general help, or info on a specific command like: \"!help balance\""
         };
 
-        private readonly CommandProcessor _commandProcessor;
-        public HelpCommand(CommandProcessor commandProcessor) => _commandProcessor = commandProcessor;
+        private readonly ICommandProcessor _commandProcessor;
+        public HelpCommand(ICommandProcessor commandProcessor) => _commandProcessor = commandProcessor;
 
         private CommandResult Execute(CommandContext context)
         {

TPP.Core/Modes/ModeBase.cs

@@ -25,7 +25,7 @@ public sealed class ModeBase : IDisposable
         private readonly ILogger<ModeBase> _logger;
         private readonly IImmutableDictionary<string, IChat> _chats;
         private readonly IImmutableDictionary<string, ICommandResponder> _commandResponders;
-        private readonly IImmutableDictionary<string, CommandProcessor> _commandProcessors;
+        private readonly IImmutableDictionary<string, ICommandProcessor> _commandProcessors;
         private readonly IImmutableDictionary<string, IModerator> _moderators;
         private readonly IImmutableDictionary<string, AdvertisePollsWorker> _advertisePollsWorkers;
         private readonly IMessagequeueRepo _messagequeueRepo;
@@ -105,7 +105,7 @@ public ModeBase(
 
         public void InstallAdditionalCommand(Command command)
         {
-            foreach (CommandProcessor commandProcessor in _commandProcessors.Values)
+            foreach (ICommandProcessor commandProcessor in _commandProcessors.Values)
                 commandProcessor.InstallCommand(command);
         }
 

TPP.Core/Setups.cs

@@ -59,7 +59,7 @@ public static ArgsParser SetUpArgsParser(IUserRepo userRepo, PokedexData pokedex
             return argsParser;
         }
 
-        public static CommandProcessor SetUpCommandProcessor(
+        public static ICommandProcessor SetUpCommandProcessor(
             ILoggerFactory loggerFactory,
             ArgsParser argsParser,
             Databases databases,
@@ -68,9 +68,9 @@ public static CommandProcessor SetUpCommandProcessor(
             IChatModeChanger chatModeChanger,
             IImmutableSet<Common.PkmnSpecies> knownSpecies)
         {
-            var commandProcessor = new CommandProcessor(
+            ICommandProcessor commandProcessor = new CommandProcessor(
                 loggerFactory.CreateLogger<CommandProcessor>(),
-                databases.CommandLogger, argsParser);
+                databases.CommandLogger, argsParser, SystemClock.Instance);
 
             IEnumerable<Command> commands = new[]
             {
@@ -180,7 +180,7 @@ public static (WebsocketBroadcastServer, OverlayConnection) SetUpOverlayServer(
         }
 
         private static void SetUpDynamicCommands(
-            ILogger logger, CommandProcessor commandProcessor, IResponseCommandRepo responseCommandRepo)
+            ILogger logger, ICommandProcessor commandProcessor, IResponseCommandRepo responseCommandRepo)
         {
             IImmutableList<ResponseCommand> commands = responseCommandRepo.GetCommands().Result;