Added command routing

Added router class using attributes
Added success parameter to mc computer response
Added generic answer type class (for future choice results)

Changelog: added
This commit is contained in:
Michael Chen 2022-01-15 21:26:32 +01:00
parent bef9d16888
commit ede4efa4e3
No known key found for this signature in database
GPG Key ID: 1CBC7AA5671437BB
7 changed files with 210 additions and 120 deletions

View File

@ -0,0 +1,30 @@
using Discord;
using Discord.WebSocket;
using System.Reflection;
namespace MinecraftDiscordBot;
public abstract class CommandRouter<T> : ICommandHandler<T> {
private readonly Dictionary<string, HandleCommandDelegate<T>> _handlers = new();
public CommandRouter() {
foreach (var method in GetType().GetMethods())
if (GetHandlerAttribute(method) is CommandHandlerAttribute handler)
try {
_handlers.Add(handler.CommandName, method.CreateDelegate<HandleCommandDelegate<T>>(this));
} catch (Exception) {
Program.LogWarning("CommandRouter", $"Could not add delegate for method {handler.CommandName} in function {method.ReturnType} {method.Name}(...)!");
throw;
}
}
private static CommandHandlerAttribute? GetHandlerAttribute(MethodInfo method)
=> method.GetCustomAttributes(typeof(CommandHandlerAttribute), true).OfType<CommandHandlerAttribute>().FirstOrDefault();
public abstract Task<T> RootAnswer(SocketUserMessage message, CancellationToken ct);
public abstract Task<T> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct);
public Task<T> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
=> parameters is { Length: 0 }
? RootAnswer(message, ct)
: _handlers.TryGetValue(parameters[0], out var handler)
? handler(message, parameters[1..], ct)
: FallbackHandler(message, parameters[0], parameters[1..], ct);
}

View File

@ -3,13 +3,23 @@ using Discord.WebSocket;
using Fleck;
using Newtonsoft.Json;
using System.Diagnostics;
using System.Runtime.Serialization;
using System.Text;
namespace MinecraftDiscordBot;
public class ConnectedComputer {
public delegate Task<TResponse> HandleCommandDelegate<TResponse>(SocketUserMessage message, string[] parameters, CancellationToken ct);
public delegate Task HandleCommandDelegate(SocketUserMessage message, string[] parameters, CancellationToken ct);
[AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
public sealed class CommandHandlerAttribute : Attribute {
public CommandHandlerAttribute(string commandName) => CommandName = commandName;
public string CommandName { get; }
}
public class ConnectedComputer : CommandRouter<ResponseType> {
protected readonly IWebSocketConnection _socket;
public ConnectedComputer(IWebSocketConnection socket) {
public ConnectedComputer(IWebSocketConnection socket) : base() {
socket.OnMessage = OnMessage;
_socket = socket;
}
@ -23,6 +33,7 @@ public class ConnectedComputer {
return;
}
}
if (!msg.Success) waiter.SetUnsuccessful();
waiter.AddChunk(msg.Chunk, msg.Total, msg.Result);
if (waiter.Finished || waiter.IsCancellationRequested)
lock (_syncRoot)
@ -40,6 +51,7 @@ public class ConnectedComputer {
int ID { get; }
bool IsCancellationRequested { get; }
void AddChunk(int chunkId, int totalChunks, string value);
void SetUnsuccessful();
}
protected class ChunkWaiter<T> : IChunkWaiter {
@ -57,6 +69,7 @@ public class ConnectedComputer {
public bool IsCancellationRequested => _ct.IsCancellationRequested;
private string?[]? _chunks = null;
private int _receivedChunks = 0;
private bool _success = true;
private readonly object _syncRoot = new();
public void AddChunk(int chunkId, int totalChunks, string value) {
lock (_syncRoot) {
@ -75,9 +88,12 @@ public class ConnectedComputer {
if (++_receivedChunks == totalChunks) FinalizeResult(_chunks);
}
private void FinalizeResult(string?[] _chunks) {
tcs.SetResult(resultParser(string.Concat(_chunks)));
var resultString = string.Concat(_chunks);
if (_success) tcs.SetResult(resultParser(resultString));
else tcs.SetException(new ReplyException(resultString));
Finished = true;
}
public void SetUnsuccessful() => _success = false;
}
protected int GetFreeId() {
@ -101,9 +117,7 @@ public class ConnectedComputer {
protected static Func<string, T> Deserialize<T>() => msg
=> JsonConvert.DeserializeObject<T>(msg) ?? throw new InvalidProgramException("Empty response!");
}
public class RefinedStorageComputer : ConnectedComputer {
public const string Role = "rs";
private const string CmdEnergyUsage = "energyusage";
private const string CmdEnergyStorage = "energystorage";
@ -111,7 +125,6 @@ public class RefinedStorageComputer : ConnectedComputer {
private const string CmdItemName = "itemname";
private const string CmdListFluids = "listfluids";
public RefinedStorageComputer(IWebSocketConnection socket) : base(socket) { }
public async Task<int> GetEnergyUsageAsync(CancellationToken ct) {
var waiter = GetWaiter(int.Parse, ct);
await Send(new RequestMessage(waiter.ID, CmdEnergyUsage));
@ -134,46 +147,21 @@ public class RefinedStorageComputer : ConnectedComputer {
return await waiter.Task;
}
public async Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
if (parameters is not { Length: > 0 }) {
await message.ReplyAsync($"Refined Storage system is online");
return;
}
try {
switch (parameters[0].ToLower()) {
case CmdEnergyUsage:
await message.ReplyAsync($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
break;
case CmdEnergyStorage:
await message.ReplyAsync($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
break;
case CmdListItems:
await HandleItemListing(message, ct);
break;
case CmdItemName:
await HandleItemName(message, parameters, ct);
break;
case CmdListFluids:
await HandleFluidListing(message, ct);
break;
case string other:
await message.ReplyAsync($"Refined Storages cannot do '{other}', bruh");
break;
}
} catch (TaskCanceledException) {
await message.ReplyAsync("The Refined Storage system request timed out!");
}
}
private async Task HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
if (parameters.Length < 2) await message.ReplyAsync($"Usage: {CmdItemName} filters...");
[CommandHandler(CmdEnergyStorage)]
public async Task<ResponseType> HandleEnergyStorage(SocketUserMessage message, string[] parameters, CancellationToken ct)
=> ResponseType.AsString($"Refined Storage system stores {await GetEnergyStorageAsync(ct)} RF/t");
[CommandHandler(CmdEnergyUsage)]
public async Task<ResponseType> HandleEnergyUsage(SocketUserMessage message, string[] parameters, CancellationToken ct)
=> ResponseType.AsString($"Refined Storage system currently uses {await GetEnergyUsageAsync(ct)} RF/t");
[CommandHandler(CmdItemName)]
public async Task<ResponseType> HandleItemName(SocketUserMessage message, string[] parameters, CancellationToken ct) {
if (parameters.Length < 2) return ResponseType.AsString($"Usage: {CmdItemName} filters...");
else {
var items = await FilterItems(message, parameters[1..], ct);
var sb = new StringBuilder();
sb.AppendLine("Did you mean:");
sb.AppendJoin("\n", items.Select(i => i.ToString()));
await message.ReplyAsync(sb.ToString());
return ResponseType.AsString(sb.ToString());
}
}
@ -188,51 +176,22 @@ public class RefinedStorageComputer : ConnectedComputer {
return items.ToList();
}
public abstract class ItemFilter {
public abstract bool Match(Fluid item);
public virtual bool MatchItem(Item item) => Match(item);
public static ItemFilter Parse(string filter)
=> filter.StartsWith('@')
? new ModNameFilter(filter[1..])
: filter.StartsWith('$')
? new TagFilter(filter[1..])
: new ItemNameFilter(filter);
private class ModNameFilter : ItemFilter {
private readonly string filter;
public ModNameFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
}
private class TagFilter : ItemFilter {
private readonly string filter;
public TagFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item)
=> item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
}
private class ItemNameFilter : ItemFilter {
private readonly string filter;
public ItemNameFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
}
}
private async Task HandleFluidListing(SocketUserMessage message, CancellationToken ct) {
[CommandHandler(CmdListFluids)]
public async Task<ResponseType> HandleFluidListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
var sb = new StringBuilder();
sb.Append("The Refined Storage system stores those fluids:");
var fluids = await ListFluidsAsync(ct);
foreach (var fluid in fluids.OrderByDescending(i => i.Amount))
if (fluid.Amount > 10000) sb.AppendFormat("\n{0:n2} B of {1}", fluid.Amount / 1000.0f, fluid.DisplayName);
else sb.AppendFormat("\n{0:n0} mB of {1}", fluid.Amount, fluid.DisplayName);
await message.ReplyAsync(sb.ToString());
return ResponseType.AsString(sb.ToString());
}
private List<Item>? Items;
private readonly object _itemLock = new();
private async Task HandleItemListing(SocketUserMessage message, CancellationToken ct) {
[CommandHandler(CmdListItems)]
public async Task<ResponseType> HandleItemListing(SocketUserMessage message, string[] parameters, CancellationToken ct) {
var sb = new StringBuilder();
sb.Append("The Refined Storage system currently stores these items:");
var items = await RefreshItemList(ct);
@ -245,7 +204,7 @@ public class RefinedStorageComputer : ConnectedComputer {
}
if (items.Count > taken) sb.AppendFormat("\nand {0} more items.", items.Skip(taken).Sum(i => i.Amount));
}
await message.ReplyAsync(sb.ToString());
return ResponseType.AsString(sb.ToString());
}
private async Task<List<Item>> RefreshItemList(CancellationToken ct) {
@ -255,6 +214,19 @@ public class RefinedStorageComputer : ConnectedComputer {
return Items;
}
}
public override Task<ResponseType> RootAnswer(SocketUserMessage message, CancellationToken ct)
=> Task.FromResult(ResponseType.AsString("The Minecraft server is connected!"));
public override Task<ResponseType> FallbackHandler(SocketUserMessage message, string method, string[] parameters, CancellationToken ct)
=> Task.FromResult(ResponseType.AsString($"What the fuck do you mean by '{method}'?"));
}
[Serializable]
public class ReplyException : Exception {
public ReplyException() { }
public ReplyException(string message) : base(message) { }
public ReplyException(string message, Exception inner) : base(message, inner) { }
protected ReplyException(SerializationInfo info, StreamingContext context) : base(info, context) { }
}
[JsonObject(MemberSerialization.OptIn, Description = "Describes an item in a Refined Storage system.", MissingMemberHandling = MissingMemberHandling.Ignore)]

View File

@ -0,0 +1,11 @@
using Discord.WebSocket;
namespace MinecraftDiscordBot;
public interface ICommandHandler {
Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
}
public interface ICommandHandler<T> {
Task<T> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct);
}

View File

@ -0,0 +1,32 @@
namespace MinecraftDiscordBot;
public abstract class ItemFilter {
public abstract bool Match(Fluid item);
public virtual bool MatchItem(Item item) => Match(item);
public static ItemFilter Parse(string filter)
=> filter.StartsWith('@')
? new ModNameFilter(filter[1..])
: filter.StartsWith('$')
? new TagFilter(filter[1..])
: new ItemNameFilter(filter);
private class ModNameFilter : ItemFilter {
private readonly string filter;
public ModNameFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item) => item.ItemId.ModName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
}
private class TagFilter : ItemFilter {
private readonly string filter;
public TagFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item)
=> item.Tags?.Any(tag => tag.Contains(filter, StringComparison.InvariantCultureIgnoreCase)) ?? false;
}
private class ItemNameFilter : ItemFilter {
private readonly string filter;
public ItemNameFilter(string filter) => this.filter = filter;
public override bool Match(Fluid item) => item.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase);
}
}

View File

@ -11,7 +11,7 @@ public abstract class Message {
public class CapabilityMessage : Message {
public override string Type => "roles";
[JsonProperty("role", Required = Required.Always)]
public string Role { get; set; } = default!;
public string[] Role { get; set; } = default!;
}
public class TextMessage : Message {
@ -36,10 +36,15 @@ public class ReplyMessage : Message {
public int AnswerId { get; set; }
[JsonProperty("result", Required = Required.Always)]
public string Result { get; set; }
[JsonProperty("chunk", Required = Required.Always)]
public int Chunk { get; set; }
[JsonProperty("total", Required = Required.Always)]
public int Total { get; set; }
[JsonProperty("chunk", Required = Required.DisallowNull)]
public int Chunk { get; set; } = 1;
[JsonProperty("total", Required = Required.DisallowNull)]
public int Total { get; set; } = 1;
/// <summary>
/// If at least one packet was received where
/// </summary>
[JsonProperty("success", Required = Required.DisallowNull)]
public bool Success { get; set; } = true;
public override string Type => "reply";
}

View File

@ -21,6 +21,7 @@
<PackageReference Include="Fleck" Version="1.2.0" />
<PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.14.0" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
<PackageReference Include="OneOf" Version="3.0.205" />
</ItemGroup>
</Project>

View File

@ -1,17 +1,18 @@
using CommandLine;
using CommandLine;
using Discord;
using Discord.Commands;
using Discord.Rest;
using Discord.WebSocket;
using Fleck;
using Newtonsoft.Json;
using OneOf;
using System.Collections.Concurrent;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace MinecraftDiscordBot;
public class Program : IDisposable {
public class Program : IDisposable, ICommandHandler<ResponseType> {
public const string WebSocketSource = "WebSocket";
public const string BotSource = "Bot";
private static readonly object LogLock = new();
@ -25,16 +26,18 @@ public class Program : IDisposable {
private readonly ConcurrentDictionary<Guid, ConnectedComputer> _connections = new();
private static readonly char[] WhiteSpace = new char[] { '\t', '\n', ' ', '\r' };
public ITextChannel[] _channels = Array.Empty<ITextChannel>();
private RefinedStorageComputer? _rsSystem = null;
private ConnectedComputer? _rsSystem = null;
private bool disposedValue;
public static bool OnlineNotifications => false;
public RefinedStorageComputer? RsSystem {
public ConnectedComputer? Computer {
get => _rsSystem; set {
if (_rsSystem != value) {
_rsSystem = value;
_ = Task.Run(() => Broadcast(i => i.SendMessageAsync(value is null
? $"The Refined Storage went offline. Please check the server!"
: $"The Refined Storage is back online!")));
if (OnlineNotifications)
_ = Task.Run(() => Broadcast(i => i.SendMessageAsync(value is null
? $"The Refined Storage went offline. Please check the server!"
: $"The Refined Storage is back online!")));
}
}
}
@ -115,27 +118,13 @@ public class Program : IDisposable {
}
}
private async Task SocketReceived(IWebSocketConnection socket, string message) {
if (JsonConvert.DeserializeObject<CapabilityMessage>(message) is not CapabilityMessage capability) return;
private static async Task SocketReceived(IWebSocketConnection socket, string message)
=> await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Received: {message}");
try {
var pc = capability.Role switch {
RefinedStorageComputer.Role => new RefinedStorageComputer(socket),
string role => throw new ArgumentException($"Invalid role '{role}'!")
};
AddComputerSocket(socket, pc);
await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Presented capability as {pc.GetType().Name}");
} catch (ArgumentException e) {
await LogErrorAsync(WebSocketSource, e);
}
}
private void AddComputerSocket(IWebSocketConnection socket, ConnectedComputer pc) {
if (pc is RefinedStorageComputer rs) RsSystem = rs;
}
private void AddComputerSocket(IWebSocketConnection socket, ConnectedComputer pc) => Computer = pc;
private void RemoveComputerSocket(IWebSocketConnection socket) {
if (RsSystem?.ConnectionInfo.Id == socket.ConnectionInfo.Id) RsSystem = null;
if (Computer is { ConnectionInfo.Id: Guid id } && id == socket.ConnectionInfo.Id) Computer = null;
}
private async Task SocketClosed(IWebSocketConnection socket) {
@ -143,8 +132,10 @@ public class Program : IDisposable {
await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client disconnected!");
}
private static async Task SocketOpened(IWebSocketConnection socket)
=> await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
private async Task SocketOpened(IWebSocketConnection socket) {
AddComputerSocket(socket, new(socket));
await LogInfoAsync(WebSocketSource, $"[{socket.ConnectionInfo.Id}] Client connected from {socket.ConnectionInfo.ClientIpAddress}:{socket.ConnectionInfo.ClientPort}!");
}
private async Task DiscordMessageReceived(SocketMessage arg, int timeout = 10000) {
if (arg is not SocketUserMessage message) return;
@ -155,7 +146,10 @@ public class Program : IDisposable {
if (IsCommand(message, out var argPos)) {
var parameters = message.Content[argPos..].Split(WhiteSpace, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
_ = Task.Run(() => HandleCommand(message, parameters, cts.Token));
_ = Task.Run(async () => {
var response = await HandleCommand(message, parameters, cts.Token);
await SendResponse(message, response);
});
return;
}
@ -163,18 +157,34 @@ public class Program : IDisposable {
// TODO: Relay Message to Chat Receiver
}
private Task HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
=> parameters is { Length: > 0 }
? parameters[0].ToLower() switch {
RefinedStorageComputer.Role => HandleRefinedStorageCommand(message, parameters[1..], ct),
_ => message.ReplyAsync($"What the fuck do you mean by '{parameters[0]}'?")
}
: message.ReplyAsync($"You really think an empty command works?");
private static Task SendResponse(SocketUserMessage message, ResponseType response) => response switch {
ResponseType.IChoiceResponse res => HandleChoice(message, res),
ResponseType.StringResponse res => message.ReplyAsync(res.Message),
_ => message.ReplyAsync($"Whoops, someone forgot to implement '{response.GetType()}' responses?"),
};
private Task HandleRefinedStorageCommand(SocketUserMessage message, string[] parameters, CancellationToken ct)
=> RsSystem is RefinedStorageComputer rs
? rs.HandleCommand(message, parameters, ct)
: message.ReplyAsync("The Refined Storage system is currently unavailable!");
private static async Task HandleChoice(SocketUserMessage message, ResponseType.IChoiceResponse res) {
var reply = await message.ReplyAsync($"{res.Query}\n{string.Join("\n", res.Options)}");
var reactions = new Emoji[] { new("0⃣"), new("1⃣"), new("2⃣"), new("3⃣"), new("4⃣"), new("5⃣"), new("6⃣"), new("7⃣"), new("8⃣"), new("9⃣") };
await reply.AddReactionsAsync(reactions);
}
public async Task<ResponseType> HandleCommand(SocketUserMessage message, string[] parameters, CancellationToken ct) {
return ResponseType.FromChoice("Select an emoji:", new[] { "One", "Two", "Nine", "420" }, (choice) => message.ReplyAsync($"You chose: {choice}"));
if (Computer is ICommandHandler<ResponseType> handler)
try {
return await handler.HandleCommand(message, parameters, ct);
} catch (TaskCanceledException) {
return ResponseType.AsString("Your request could not be processed in time!");
} catch (ReplyException e) {
await LogWarningAsync(BotSource, e.Message);
return ResponseType.AsString($"Your request failed: {e.Message}");
} catch (Exception e) {
await LogErrorAsync(BotSource, e);
return ResponseType.AsString($"Oopsie doopsie, this should not have happened!");
}
else return ResponseType.AsString("The Minecraft server is currently unavailable!");
}
private bool IsCommand(SocketUserMessage message, out int argPos) {
argPos = 0;
@ -227,3 +237,32 @@ public class Program : IDisposable {
GC.SuppressFinalize(this);
}
}
public abstract class ResponseType {
private static string DefaultDisplay<T>(T obj) => obj?.ToString() ?? throw new InvalidProgramException("ToString did not yield anything!");
public static ResponseType AsString(string message) => new StringResponse(message);
public static ResponseType FromChoice<T>(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string>? display = null) => new ChoiceResponse<T>(query, choice, resultHandler, display ?? DefaultDisplay);
public class StringResponse : ResponseType {
public StringResponse(string message) => Message = message;
public string Message { get; }
}
public interface IChoiceResponse {
IEnumerable<string> Options { get; }
string Query { get; }
Task HandleResult(int index);
}
public class ChoiceResponse<T> : ResponseType, IChoiceResponse {
private readonly Func<T, Task> _resultHandler;
private readonly T[] _options;
private readonly Func<T, string> _displayer;
public IEnumerable<string> Options => _options.Select(_displayer);
public string Query { get; }
public Task HandleResult(int index) => _resultHandler(_options[index]);
public ChoiceResponse(string query, IEnumerable<T> choice, Func<T, Task> resultHandler, Func<T, string> display) {
Query = query;
_resultHandler = resultHandler;
_options = choice.ToArray();
_displayer = display;
}
}
}