Add dynamic dependency manager with relocation

build.gradle

@@ -36,12 +36,17 @@ allprojects {
             name 'velocity'
             url 'https://nexus.velocitypowered.com/repository/maven-public/'
         }
+        maven {
+            // Mirror other people's repositories
+            name 'diogotcRepositoryMirror'
+            url 'https://repo.diogotc.com/mirror/'
+        }
     }
 }
 
 subprojects {
     dependencies {
-        implementation 'org.jetbrains:annotations:23.0.0'
+        compileOnly 'org.jetbrains:annotations:23.0.0'
 
         compileOnly 'org.projectlombok:lombok:1.18.22'
         annotationProcessor 'org.projectlombok:lombok:1.18.22'
@@ -52,18 +57,34 @@ subprojects {
 }
 
 dependencies {
+    implementation project(':api')
+    implementation project(':core:triton-core-loader')
+    implementation project(':triton-bungeecord:triton-bungeecord-loader')
+    implementation project(':triton-spigot:triton-spigot-loader')
+    implementation project(':triton-velocity:triton-velocity-loader')
 
-    implementation project(path: ":core")
-    implementation project(path: ":triton-bungeecord")
-    implementation project(path: ":triton-spigot")
-    implementation project(path: ":triton-velocity")
+    compileOnly project(':core')
+    compileOnly project(':triton-bungeecord')
+    compileOnly project(':triton-spigot')
+    compileOnly project(':triton-velocity')
 }
 
 shadowJar {
     getArchiveBaseName().set(rootProject.name)
-    relocate 'org.bstats', 'com.rexcantor64.triton.metrics'
-    //relocate 'org.slf4j', 'com.rexcantor64.shaded.slf4j'
-    relocate 'net.kyori.adventure.text.minimessage', 'com.rexcantor64.shaded.minimessage'
-    relocate 'com.tananaev.jsonpatch', 'com.rexcantor64.shaded.jsonpatch'
-    relocate 'com.zaxxer.hikari', 'com.rexcantor64.shaded.hikari'
+
+    from {
+        project(':core').tasks.shadowJar.archiveFile
+    }
+    from {
+        project(':triton-bungeecord').tasks.shadowJar.archiveFile
+    }
+    from {
+        project(':triton-spigot').tasks.shadowJar.archiveFile
+    }
+    from {
+        project(':triton-velocity').tasks.shadowJar.archiveFile
+    }
+
+    relocate 'org.objectweb.asm', 'com.rexcantor64.triton.lib.objectweb.asm'
+    relocate 'me.lucko.jarrelocator', 'com.rexcantor64.triton.lib.jarrelocator'
 }

core/build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java'
+    id 'com.github.johnrengelman.shadow' version '7.1.0'
 }
 
 group 'com.rexcantor64.triton'
@@ -9,14 +10,14 @@ test {
 }
 
 dependencies {
-    implementation project(path: ":api")
+    compileOnly project(':core:triton-core-loader')
+    compileOnly project(":api")
 
     // Adventure / MiniMessage
-    // TODO check which of these should be compileOnly or implementation
     compileOnly 'net.kyori:adventure-text-serializer-gson:4.15.0'
     compileOnly 'net.kyori:adventure-text-serializer-legacy:4.15.0'
     compileOnly 'net.kyori:adventure-text-serializer-plain:4.15.0'
-    implementation('net.kyori:adventure-text-minimessage:4.15.0') {
+    compileOnly('net.kyori:adventure-text-minimessage:4.15.0') {
         exclude group: 'net.kyori', module: 'adventure-api'
         exclude group: 'net.kyori', module: 'adventure-key'
         exclude group: 'net.kyori', module: 'adventure-text-serialize-gson'
@@ -37,7 +38,11 @@ dependencies {
     }
     compileOnly 'com.google.code.gson:gson:2.9.0'
 
+    implementation 'net.byteflux:libby-core:1.3.0'
+
     // Test dependencies
+    testImplementation project(":api")
+
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
 
@@ -46,3 +51,20 @@ dependencies {
     testImplementation 'net.kyori:adventure-text-serializer-legacy:4.15.0'
     testImplementation 'net.kyori:adventure-text-serializer-plain:4.15.0'
 }
+
+shadowJar {
+    archiveFileName = 'triton-core.jarinjar'
+
+    relocate 'org.bstats', 'com.rexcantor64.triton.metrics'
+    //relocate 'org.slf4j', 'com.rexcantor64.shaded.slf4j'
+    relocate 'com.tananaev.jsonpatch', 'com.rexcantor64.shaded.jsonpatch'
+    relocate 'com.zaxxer.hikari', 'com.rexcantor64.shaded.hikari'
+
+    relocate 'net.kyori.adventure.text.minimessage', 'com.rexcantor64.triton.lib.adventure.text.minimessage'
+    relocate 'net.kyori.adventure.text.serializer.gson', 'com.rexcantor64.triton.lib.adventure.text.serializer.gson'
+    relocate 'net.kyori.adventure.text.serializer.legacy', 'com.rexcantor64.triton.lib.adventure.text.serializer.legacy'
+    relocate 'net.kyori.adventure.text.serializer.plain', 'com.rexcantor64.triton.lib.adventure.text.serializer.plain'
+    relocate 'net.kyori.adventure.text.serializer.bungeecord', 'com.rexcantor64.triton.lib.adventure.text.serializer.bungeecord'
+
+    relocate 'net.byteflux.libby', 'com.rexcantor64.triton.lib.libby'
+}

core/loader/build.gradle

@@ -0,0 +1,11 @@
+plugins {
+    id 'java-library'
+}
+
+group 'com.rexcantor64.triton'
+
+dependencies {
+    api 'org.ow2.asm:asm-commons:9.2'
+    api 'org.ow2.asm:asm:9.2'
+    api 'me.lucko:jar-relocator:1.7'
+}

core/loader/src/main/java/com/rexcantor64/triton/loader/utils/CommonLoader.java

@@ -0,0 +1,40 @@
+package com.rexcantor64.triton.loader.utils;
+
+import lombok.Builder;
+import lombok.Singular;
+import me.lucko.jarrelocator.Relocation;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+@Builder
+public class CommonLoader {
+    private static final String CORE_JAR_NAME = "triton-core.jarinjar";
+
+    private final String jarInJarName;
+    private final String bootstrapClassName;
+    @Singular
+    private final Set<LoaderFlag> flags;
+    @Singular
+    private final List<Class<?>> constructorTypes;
+    @Singular
+    private final List<Object> constructorValues;
+
+    public LoaderBootstrap loadPlugin() {
+        List<Relocation> relocations = new ArrayList<>();
+        if (flags.contains(LoaderFlag.RELOCATE_ADVENTURE)) {
+            relocations.add(new Relocation("net/kyori/adventure", "com/rexcantor64/triton/lib/adventure"));
+        }
+
+        @SuppressWarnings("resource")
+        JarInJarClassLoader loader = new JarInJarClassLoader(getClass().getClassLoader(), relocations, CORE_JAR_NAME, jarInJarName);
+
+        Class<?>[] constructorTypes = this.constructorTypes.toArray(new Class<?>[this.constructorTypes.size() + 1]);
+        constructorTypes[constructorTypes.length - 1] = Set.class;
+        Object[] constructorValues = this.constructorValues.toArray(new Object[this.constructorValues.size() + 1]);
+        constructorValues[constructorValues.length - 1] = Collections.unmodifiableSet(this.flags);
+        return loader.instantiatePlugin(bootstrapClassName, constructorTypes, constructorValues);
+    }
+}

core/loader/src/main/java/com/rexcantor64/triton/loader/utils/JarInJarClassLoader.java

@@ -0,0 +1,166 @@
+package com.rexcantor64.triton.loader.utils;
+
+import me.lucko.jarrelocator.JarRelocator;
+import me.lucko.jarrelocator.Relocation;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Classloader that can load a jar from within another jar file.
+ *
+ * <p>The "loader" jar contains the loading code & public API classes,
+ * and is class-loaded by the platform.</p>
+ *
+ * <p>The inner "plugin" jar contains the plugin itself, and is class-loaded
+ * by the loading code & this classloader.</p>
+ */
+public class JarInJarClassLoader extends URLClassLoader {
+    static {
+        ClassLoader.registerAsParallelCapable();
+    }
+
+    /**
+     * Creates a new jar-in-jar class loader.
+     *
+     * @param loaderClassLoader the loader plugin's classloader (setup and created by the platform)
+     * @param jarResourcePaths  one or more paths to the jar-in-jar resources within the loader jar
+     * @throws LoadingException if something unexpectedly bad happens
+     */
+    public JarInJarClassLoader(ClassLoader loaderClassLoader, List<Relocation> relocations, String... jarResourcePaths) throws LoadingException {
+        super(
+                Arrays.stream(jarResourcePaths)
+                        .map(path -> extractJar(loaderClassLoader, path, relocations))
+                        .toArray(URL[]::new),
+                loaderClassLoader);
+    }
+
+    public void addJarToClasspath(URL url) {
+        addURL(url);
+    }
+
+    public void deleteJarResource() {
+        URL[] urls = getURLs();
+        if (urls.length == 0) {
+            return;
+        }
+
+        try {
+            Path path = Paths.get(urls[0].toURI());
+            Files.deleteIfExists(path);
+        } catch (Exception e) {
+            // ignore
+        }
+    }
+
+    /**
+     * Creates a new plugin instance.
+     *
+     * @param bootstrapClass   the name of the bootstrap plugin class
+     * @param loaderPluginType the type of the loader plugin, the only parameter of the bootstrap
+     *                         plugin constructor
+     * @param loaderPlugin     the loader plugin instance
+     * @param <T>              the type of the loader plugin
+     * @return the instantiated bootstrap plugin
+     */
+    public <T> LoaderBootstrap instantiatePlugin(String bootstrapClass, Class<T> loaderPluginType, T loaderPlugin) throws LoadingException {
+        return this.instantiatePlugin(bootstrapClass, new Class[]{loaderPluginType}, new Object[]{loaderPlugin});
+    }
+
+    /**
+     * Creates a new plugin instance.
+     *
+     * @param bootstrapClass   the name of the bootstrap plugin class
+     * @param constructorTypes the types of the constructor of the bootstrap plugin class
+     * @param constructorArgs  the values to pass to the constructor
+     * @return the instantiated bootstrap plugin
+     */
+    public LoaderBootstrap instantiatePlugin(String bootstrapClass, Class<?>[] constructorTypes, Object[] constructorArgs) throws LoadingException {
+        Class<? extends LoaderBootstrap> plugin;
+        try {
+            plugin = loadClass(bootstrapClass).asSubclass(LoaderBootstrap.class);
+        } catch (ReflectiveOperationException e) {
+            throw new LoadingException("Unable to load bootstrap class", e);
+        }
+
+        Constructor<? extends LoaderBootstrap> constructor;
+        try {
+            constructor = plugin.getConstructor(constructorTypes);
+        } catch (ReflectiveOperationException e) {
+            throw new LoadingException("Unable to get bootstrap constructor", e);
+        }
+
+        try {
+            return constructor.newInstance(constructorArgs);
+        } catch (ReflectiveOperationException e) {
+            throw new LoadingException("Unable to create bootstrap plugin instance", e);
+        }
+    }
+
+    /**
+     * Extracts the "jar-in-jar" from the loader plugin into a temporary file,
+     * then returns a URL that can be used by the {@link JarInJarClassLoader}.
+     *
+     * @param loaderClassLoader the classloader for the "host" loader plugin
+     * @param jarResourcePath   the inner jar resource path
+     * @return a URL to the extracted file
+     */
+    private static URL extractJar(ClassLoader loaderClassLoader, String jarResourcePath, List<Relocation> relocations) throws LoadingException {
+        // get the jar-in-jar resource
+        URL jarInJar = loaderClassLoader.getResource(jarResourcePath);
+        if (jarInJar == null) {
+            throw new LoadingException("Could not locate jar-in-jar");
+        }
+
+        // create a temporary file
+        // on posix systems by default this is only read/writable by the process owner
+        Path path;
+        Path pathRelocated;
+        try {
+            path = Files.createTempFile(jarResourcePath.replace('.', '-'), ".jar.tmp");
+            pathRelocated = Files.createTempFile(jarResourcePath.replace('.', '-'), "-relocated.jar.tmp");
+        } catch (IOException e) {
+            throw new LoadingException("Unable to create a temporary file", e);
+        }
+
+        // mark that the file should be deleted on exit
+        path.toFile().deleteOnExit();
+        pathRelocated.toFile().deleteOnExit();
+
+        // copy the jar-in-jar to the temporary file path
+        try (InputStream in = jarInJar.openStream()) {
+            Files.copy(in, path, StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            throw new LoadingException("Unable to copy jar-in-jar to temporary path", e);
+        }
+
+        if (!relocations.isEmpty()) {
+            try {
+                new JarRelocator(path.toFile(), pathRelocated.toFile(), relocations).run();
+            } catch (IOException e) {
+                throw new LoadingException("Unable to apply relocations to jar", e);
+            }
+        }
+
+        try {
+            if (relocations.isEmpty()) {
+                return path.toUri().toURL();
+            } else {
+                return pathRelocated.toUri().toURL();
+            }
+        } catch (MalformedURLException e) {
+            throw new LoadingException("Unable to get URL from path", e);
+        }
+    }
+
+}

core/loader/src/main/java/com/rexcantor64/triton/loader/utils/LoaderBootstrap.java

@@ -0,0 +1,12 @@
+package com.rexcantor64.triton.loader.utils;
+
+/**
+ * Minimal bootstrap plugin, called by the loader plugin.
+ */
+public interface LoaderBootstrap {
+
+    default void onEnable() {}
+
+    default void onDisable() {}
+
+}

core/loader/src/main/java/com/rexcantor64/triton/loader/utils/LoaderFlag.java

@@ -0,0 +1,5 @@
+package com.rexcantor64.triton.loader.utils;
+
+public enum LoaderFlag {
+    RELOCATE_ADVENTURE,
+}

core/loader/src/main/java/com/rexcantor64/triton/loader/utils/LoadingException.java

@@ -0,0 +1,16 @@
+package com.rexcantor64.triton.loader.utils;
+
+/**
+ * Runtime exception used if there is a problem during loading
+ */
+public class LoadingException extends RuntimeException {
+
+    public LoadingException(String message) {
+        super(message);
+    }
+
+    public LoadingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}