Add BukkitTelnet compiler

src/main/java/dev/plex/automation/PatchedTelnetCompiler.java

@@ -0,0 +1,168 @@
+package dev.plex.automation;
+
+import com.google.common.collect.ImmutableList;
+import dev.plex.BukkitTelnetModule;
+import dev.plex.util.PlexLog;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Timer;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class PatchedTelnetCompiler {
+    private static final PluginManager PLUGIN_MANAGER = Bukkit.getPluginManager();
+    private static final URI CODE_ARCHIVE = URI.create("https://github.com/plexusorg/BukkitTelnet/archive/refs/heads/master.zip");
+    private static final Path PLUGIN_DIRECTORY = Bukkit.getServer().getPluginsFolder().toPath();
+    private static final File TARGET_PLUGIN = PLUGIN_DIRECTORY.resolve("BukkitTelnet.jar").toFile();
+    private static final Path WORKING_DIRECTORY = Path.of(System.getProperty("user.dir"));
+    private static final Path ROOT_PATH = WORKING_DIRECTORY.resolve("build");
+    private static final Path EXTRACT_TARGET = ROOT_PATH.resolve("extract");
+    private static final Path EXTRACT_SUBDIR = EXTRACT_TARGET.resolve("BukkitTelnet-master");
+    private static final Path BINARIES_PATH = EXTRACT_SUBDIR.resolve("build").resolve("libs");
+    private static final String DOWNLOADED_ARCHIVE_PATH = String.valueOf(ROOT_PATH.resolve("BukkitTelnet-master.zip"));
+    private static final HttpClient HTTP_CLIENT = HttpClient.newHttpClient();
+
+    public static void execute() throws Exception {
+        // Create directories
+        final List<Path> directories = ImmutableList.of(ROOT_PATH, EXTRACT_TARGET);
+
+        for (Path directory : directories) {
+            PlexLog.debug("Checking if {0} exists...", String.valueOf(directory));
+            if (Files.notExists(directory)) {
+                PlexLog.debug("It doesn't! Creating directory...");
+                Files.createDirectory(directory);
+            }
+        }
+
+        downloadArchive();
+    }
+
+    private static void downloadArchive() throws Exception {
+        PlexLog.log("Downloading archive...");
+        // Create the request
+        final HttpRequest request = HttpRequest.newBuilder()
+                .GET()
+                // GitHub may block blank/generic user agents in the future, so we're spoofing one
+                .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36")
+                .uri(CODE_ARCHIVE)
+                .build();
+
+        // Send the request
+        final HttpResponse<String> response = HTTP_CLIENT.send(request, HttpResponse.BodyHandlers.ofString());
+
+        // Get the redirect
+        final URI redirect = URI.create(response.headers().firstValue("location").orElseThrow());
+
+        // Download the file from the redirect
+        final HttpRequest downloadRequest = HttpRequest.newBuilder()
+                .GET()
+                .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36")
+                .uri(redirect)
+                .build();
+
+        HTTP_CLIENT.send(downloadRequest, HttpResponse.BodyHandlers.ofFileDownload(ROOT_PATH, StandardOpenOption.CREATE, StandardOpenOption.WRITE));
+
+        extractArchive();
+    }
+
+    private static void extractArchive() throws Exception {
+        PlexLog.log("Extracting archive...");
+        final ZipInputStream inputStream = new ZipInputStream(new FileInputStream(DOWNLOADED_ARCHIVE_PATH));
+        ZipEntry entry = inputStream.getNextEntry();
+
+        while (entry != null) {
+            final Path outputDestination = EXTRACT_TARGET.resolve(entry.getName());
+
+            if (entry.isDirectory()) {
+                if (Files.notExists(outputDestination)) {
+                    PlexLog.debug("{0} doesn't exist, creating it!", String.valueOf(outputDestination));
+                    Files.createDirectory(outputDestination);
+                }
+            } else {
+                final FileOutputStream outputStream = new FileOutputStream(String.valueOf(outputDestination));
+                int read = 0;
+                while ((read = inputStream.read()) != -1) {
+                    outputStream.write(read);
+                }
+
+                outputStream.close();
+            }
+
+            inputStream.closeEntry();
+            entry = inputStream.getNextEntry();
+        }
+
+        executeGradleTarget();
+    }
+
+    private static void executeGradleTarget() throws Exception {
+        PlexLog.log("Executing gradle target...");
+        boolean nix = !System.getProperty("os.name").toLowerCase().contains("win"); // Assume Windows if name contains win
+
+        String gradlew = String.valueOf(nix ? EXTRACT_SUBDIR.resolve("gradlew") : EXTRACT_SUBDIR.resolve("gradlew.bat"));
+        if (nix) {
+            final ProcessBuilder chmodBuilder = new ProcessBuilder("chmod", "+x", gradlew);
+            Process chmodProcess = chmodBuilder.start();
+            chmodProcess.waitFor();
+        }
+
+        final ProcessBuilder builder = new ProcessBuilder(gradlew, "--no-daemon", "clean", "build");
+        builder.directory(new File(String.valueOf(EXTRACT_SUBDIR)));
+        PlexLog.debug("Executing compile command: {0}", builder.command());
+
+        //builder.redirectErrorStream(true);
+        //builder.redirectOutput(ProcessBuilder.Redirect.PIPE);
+        builder.inheritIO();
+
+        final Process process = builder.start();
+        process.waitFor();
+        PlexLog.debug("Compilation command ended with status code {0}", process.exitValue());
+        copyBinary();
+    }
+
+    private static void copyBinary() throws Exception {
+        PlexLog.log("Copying binaries...");
+        final File binaryDirectory = new File(String.valueOf(BINARIES_PATH));
+        final File[] files = binaryDirectory.listFiles();
+
+        if (files == null) {
+            throw new IllegalStateException("Didn't manage to compile jars!");
+        } else if (files.length == 0) {
+            throw new IllegalStateException("Didn't manage to compile jars!");
+        }
+
+        Files.copy(BINARIES_PATH.resolve("BukkitTelnet.jar"), TARGET_PLUGIN.toPath(), StandardCopyOption.REPLACE_EXISTING);
+        Files.walk(ROOT_PATH)
+                .sorted(Comparator.reverseOrder())
+                .map(Path::toFile)
+                .forEach(File::delete);
+
+        Timer timer = new Timer();
+
+        final Plugin plugin = PLUGIN_MANAGER.loadPlugin(TARGET_PLUGIN);
+        if (plugin == null) throw new IllegalStateException("BukkitTelnet cannot be null after successful compile!");
+
+        plugin.onLoad();
+        PLUGIN_MANAGER.enablePlugin(plugin);
+        done();
+    }
+
+    private static void done() {
+        BukkitTelnetModule.getModule().enable();
+    }
+}