[ci-skip] Add eval engine for debugging the clientn

Author: duncte123

testbot/build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     java
     application
+    kotlin("jvm")
 }
 
 group = "me.duncte123"
@@ -15,6 +16,9 @@ dependencies {
     // Include the lavalink client
     implementation(projects.lavalinkClient)
 
+    // implementation(kotlin("stdlib")) // Do we need this?
+    implementation(kotlin("scripting-jsr223"))
+
     // other libs such as a discord client and a logger
     implementation(libs.jda)
     implementation(libs.logger.impl)

testbot/src/main/java/me/duncte123/testbot/EvalEngine.java

@@ -0,0 +1,103 @@
+package me.duncte123.testbot;
+
+import dev.arbjerg.lavalink.client.LavalinkClient;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class EvalEngine {
+    private final ExecutorService evalThread = Executors.newThreadPerTaskExecutor(
+        (it) -> Thread.ofVirtual()
+            .name("eval-thread")
+            .unstarted(it)
+    );
+
+    private final ScriptEngine engine = new ScriptEngineManager().getEngineByExtension("kts");
+
+    private final LavalinkClient client;
+
+    public EvalEngine(LavalinkClient client) {
+        this.client = client;
+        this.initEngine();
+    }
+
+    public Object eval(SlashCommandInteractionEvent slashEvent, String code) {
+        final var bindings = new SimpleBindings();
+
+        bindings.put("client", this.client);
+        bindings.put("event", slashEvent);
+        bindings.put("guild", slashEvent.getGuild());
+        bindings.put("jda", slashEvent.getJDA());
+
+        final Future<Object> future = this.evalThread.submit(() -> {
+           try {
+               return this.engine.eval(code, bindings);
+           } catch (final Exception e) {
+               return e;
+           }
+        });
+
+
+        try {
+            return future.get(5, TimeUnit.SECONDS);
+        } catch (Exception ex) {
+            future.cancel(true);
+            return ex;
+        }
+    }
+
+    private void initEngine() {
+        final var packageImports = List.of(
+            "java.io",
+            "java.lang",
+            "java.math",
+            "java.time",
+            "java.util",
+            "java.util.concurrent",
+            "java.util.stream",
+            "net.dv8tion.jda.api",
+            "net.dv8tion.jda.internal.entities",
+            "net.dv8tion.jda.api.entities",
+            "net.dv8tion.jda.api.entities.channel",
+            "net.dv8tion.jda.api.entities.channel.attribute",
+            "net.dv8tion.jda.api.entities.channel.middleman",
+            "net.dv8tion.jda.api.entities.channel.concrete",
+            "net.dv8tion.jda.api.managers",
+            "net.dv8tion.jda.internal.managers",
+            "net.dv8tion.jda.api.utils",
+            "dev.arbjerg.lavalink.client",
+            "dev.arbjerg.lavalink.client.player",
+            "dev.arbjerg.lavalink.client.http",
+            "dev.arbjerg.lavalink.client.event"
+        );
+
+        final List<String> classImports = List.of(
+            // Nothing needed for now
+        );
+
+        // classImports.joinToString(separator = "\nimport ", postfix = "\n")
+
+        final var importString = packageImports.stream()
+            .map((i) -> "import " + i + ".*")
+            .collect(Collectors.joining("\n"))/* + classImports.stream().collect(Collectors.joining(
+            "", "\nimport ", "\n"
+        ))*/;
+
+
+        try {
+            this.engine.eval(importString);
+        } catch (ScriptException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

testbot/src/main/java/me/duncte123/testbot/JDAListener.java

@@ -17,17 +17,22 @@
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.Commands;
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import net.dv8tion.jda.api.requests.RestAction;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class JDAListener extends ListenerAdapter {
+    private static final long DUNCTE = 191231307290771456L;
+
     private static final Logger LOG = LoggerFactory.getLogger(JDAListener.class);
 
     private final LavalinkClient client;
+    private final EvalEngine evalEngine;
 
     public JDAListener(LavalinkClient client) {
         this.client = client;
+        this.evalEngine = new EvalEngine(client);
     }
 
     @Override
@@ -38,11 +43,11 @@ public void onReady(@NotNull ReadyEvent event) {
             .addCommands(
                 Commands.slash("lyrics", "Testing custom requests"),
                 Commands.slash("node", "What node am I on?"),
-                Commands.slash("del-node", "test")
+                Commands.slash("eval", "test out some code")
                     .addOption(
                         OptionType.STRING,
-                        "node-name",
-                        "Name of the node",
+                        "script",
+                        "Script to eval",
                         true
                     ),
                 Commands.slash("join", "Join the voice channel you are in."),
@@ -87,9 +92,25 @@ public void onSlashCommandInteraction(@NotNull SlashCommandInteractionEvent even
 
                 break;
             }
-            case "del-node": {
-                this.client.removeNode(event.getOption("node-name").getAsString());
-                event.reply("Ok").queue();
+            case "eval": {
+                final var user = event.getUser();
+
+                if (user.getIdLong() != DUNCTE) {
+                    event.replyFormat("I'm sorry %s, I'm afraid I can't let you do that", user.getAsMention()).queue();
+                    return;
+                }
+
+                event.deferReply().queue();
+
+                Thread.ofVirtual().start(() -> {
+                    try {
+                        final var script = event.getOption("script").getAsString();
+                        final var result = this.evalEngine.eval(event, script);
+                        this.parseEvalResult(event, result);
+                    } catch (final Exception e) {
+                        LOG.error("Failed to eval", e);
+                    }
+                });
                 break;
             }
             case "join":
@@ -242,6 +263,38 @@ public void onSlashCommandInteraction(@NotNull SlashCommandInteractionEvent even
         }
     }
 
+    private void parseEvalResult(SlashCommandInteractionEvent event, Object result) {
+        final var hook = event.getHook();
+
+        if (result == null) {
+            hook.sendMessage("No result").queue();
+            return;
+        }
+
+        switch (result) {
+            case Throwable thr: {
+                hook.sendMessage("ERROR: " + thr).queue();
+                break;
+            }
+
+            case RestAction<?> ra: {
+                ra.queue(
+                    (res) -> {
+                        hook.sendMessage("Rest action success: " + res).queue();
+                    },
+                    (err) -> {
+                        hook.sendMessage("Rest action error: " + err).queue();
+                    }
+                );
+            }
+
+            default: {
+                hook.sendMessage("result: " + result).queue();
+                break;
+            }
+        }
+    }
+
     // Makes sure that the bot is in a voice channel!
     private void joinHelper(SlashCommandInteractionEvent event) {
         final Member member = event.getMember();