Add mixin support to plugins (#218)

* Initial take on plugin mixins

* Reminder

* Removed hot_reload flag. Added mixin path list. Updated dependencies

Co-authored-by: Constructor <fractalminds@protonmail.com>

Author: Nep Nep

src/main/kotlin/com/lambda/client/LambdaCoreMod.kt

@@ -1,14 +1,14 @@
 package com.lambda.client
 
+import com.lambda.client.plugin.PluginManager
 import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin
-import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin.MCVersion
 import org.apache.logging.log4j.LogManager
 import org.spongepowered.asm.launch.MixinBootstrap
 import org.spongepowered.asm.mixin.MixinEnvironment
 import org.spongepowered.asm.mixin.Mixins
 
 @IFMLLoadingPlugin.Name("LambdaCoreMod")
-@MCVersion("1.12.2")
+@IFMLLoadingPlugin.MCVersion("1.12.2")
 class LambdaCoreMod : IFMLLoadingPlugin {
     override fun getASMTransformerClass(): Array<String> {
         return emptyArray()
@@ -22,7 +22,6 @@ class LambdaCoreMod : IFMLLoadingPlugin {
         return null
     }
 
-
     override fun injectData(data: Map<String, Any>) {}
 
     override fun getAccessTransformerClass(): String? {
@@ -34,6 +33,14 @@ class LambdaCoreMod : IFMLLoadingPlugin {
 
         MixinBootstrap.init()
         Mixins.addConfigurations("mixins.lambda.json", "mixins.baritone.json")
+
+        PluginManager.getLoaders()
+            .filter { it.info.mixins.isNotEmpty() }
+            .forEach {
+                logger.info("Initialised mixins of ${it.info.name}.")
+                Mixins.addConfigurations(*it.info.mixins)
+            }
+
         MixinEnvironment.getDefaultEnvironment().obfuscationContext = "searge"
         logger.info("Lambda and Baritone mixins initialised.")
     }

src/main/kotlin/com/lambda/client/gui/clickgui/component/PluginButton.kt

@@ -40,7 +40,7 @@ class PluginButton(var plugin: Plugin, var file: File) : BooleanSlider(plugin.na
         super.onClick(mousePos, buttonId)
         if (buttonId == 0) {
             if (isLoaded) {
-                PluginManager.unload(plugin)
+                if (!PluginManager.unload(plugin)) return
                 isLoaded = false
             } else {
                 PluginManager.load(PluginLoader(file))

src/main/kotlin/com/lambda/client/plugin/PluginError.kt

@@ -35,9 +35,12 @@ internal enum class PluginError {
     companion object {
         private var latestErrors: ArrayList<Pair<PluginLoader, PluginError>>? = null
 
-        fun log(message: String?, throwable: Throwable? = null) {
+        fun log(message: String?, shouldChat: Boolean = true, throwable: Throwable? = null) {
             message?.let {
-                MessageSendHelper.sendErrorMessage("[Plugin Manager] $it")
+                // DO NOT ACCESS MINECRAFT IN COREMODSPACE
+                if (shouldChat) {
+                    MessageSendHelper.sendErrorMessage("[Plugin Manager] $it")
+                }
 
                 if (throwable != null) {
                     LambdaMod.LOG.error(message, throwable)

src/main/kotlin/com/lambda/client/plugin/PluginInfo.kt

@@ -15,7 +15,7 @@ class PluginInfo private constructor(
     @SerializedName("min_api_version") private val minApiVersion0: String?,
     @SerializedName("required_plugins") private val requiredPlugins0: Array<String>?,
     @SerializedName("main_class") private val mainClass0: String?,
-    @SerializedName("hot_reload") private val hotReload0: Boolean?
+    @SerializedName("mixins") private val mixins0: Array<String>?
 ) : Nameable {
 
     /** The name of the plugin, will be used as both an identifier and a display name */
@@ -43,7 +43,7 @@ class PluginInfo private constructor(
     val mainClass: String get() = mainClass0.nonBlank("main_class")
 
     /** Whether this plugin can be hot reloaded or not, this should be false if the plugin uses mixin */
-    val hotReload: Boolean get() = hotReload0 ?: true
+    val mixins: Array<String> get() = mixins0 ?: mixinsNull
 
     private fun String?.nonBlank(name: String = "String") =
         when {
@@ -71,6 +71,7 @@ class PluginInfo private constructor(
         private const val descriptionNull: String = "No Description"
         private const val urlNull: String = "No Url"
         private val requiredPluginsNull: Array<String> = emptyArray()
+        private val mixinsNull: Array<String> = emptyArray()
 
         private val gson = Gson()
 

src/main/kotlin/com/lambda/client/plugin/PluginLoader.kt

@@ -6,6 +6,7 @@ import com.lambda.client.LambdaMod
 import com.lambda.client.plugin.api.Plugin
 import com.lambda.commons.interfaces.Nameable
 import com.lambda.commons.utils.ClassUtils.instance
+import net.minecraft.launchwrapper.Launch
 import java.io.File
 import java.io.FileNotFoundException
 import java.lang.reflect.Type
@@ -18,7 +19,7 @@ class PluginLoader(
 
     override val name: String get() = info.name
 
-    private val loader = PluginClassLoader(JarFile(file), this.javaClass.classLoader)
+    private var loader: ClassLoader = PluginClassLoader(JarFile(file), this.javaClass.classLoader)
     val info: PluginInfo = loader.getResourceAsStream("plugin_info.json")?.let {
         PluginInfo.fromStream(it)
     } ?: throw FileNotFoundException("plugin_info.json not found in jar ${file.name}!")
@@ -27,6 +28,13 @@ class PluginLoader(
         // This will trigger the null checks in PluginInfo
         // In order to make sure all required infos are present
         info.toString()
+
+        if (info.mixins.isNotEmpty()) {
+            Launch.classLoader.addURL(file.toURI().toURL())
+            // May not be necessary, a consistency thing for now
+            closeWithoutCheck()
+            loader = Launch.classLoader
+        }
     }
 
     fun verify(): Boolean {
@@ -42,14 +50,14 @@ class PluginLoader(
             toString()
         }
 
-        // ToDo: Do no spam when in Lambda menu
+        // ToDo: Use plugin database to verify trusted files
 //        LambdaMod.LOG.info("SHA-256 checksum for ${file.name}: $result")
 
         return checksumSets.contains(result)
     }
 
     fun load(): Plugin {
-        if (LambdaMod.ready && !info.hotReload) {
+        if (LambdaMod.ready && info.mixins.isNotEmpty()) {
             throw IllegalAccessException("Plugin $this cannot be hot reloaded!")
         }
 
@@ -68,13 +76,19 @@ class PluginLoader(
     }
 
     fun close() {
-        loader.close()
+        if (info.mixins.isEmpty()) {
+            closeWithoutCheck()
+        }
     }
 
     override fun toString(): String {
         return "${runCatching { info.name }.getOrDefault("Unknown Plugin")}(${file.name})"
     }
 
+    private fun closeWithoutCheck() {
+        (loader as PluginClassLoader).close()
+    }
+
     private companion object {
         val sha256: MessageDigest = MessageDigest.getInstance("SHA-256")
         val type: Type = object : TypeToken<HashSet<String>>() {}.type

src/main/kotlin/com/lambda/client/plugin/PluginManager.kt

@@ -69,7 +69,7 @@ internal object PluginManager : AsyncLoader<List<PluginLoader>> {
 
         for (loader in loaders) {
             // Hot reload check, the error shouldn't be show when reload in game
-            if (LambdaMod.ready && !loader.info.hotReload) {
+            if (LambdaMod.ready && loader.info.mixins.isNotEmpty()) {
                 invalids.add(loader)
             }
 
@@ -139,7 +139,7 @@ internal object PluginManager : AsyncLoader<List<PluginLoader>> {
 
     fun load(loader: PluginLoader) {
         synchronized(this) {
-            val hotReload = LambdaMod.ready && !loader.info.hotReload
+            val hotReload = LambdaMod.ready && loader.info.mixins.isNotEmpty()
             val duplicate = loadedPlugins.containsName(loader.name)
             val unsupported = DefaultArtifactVersion(loader.info.minApiVersion) > lambdaVersion
             val missing = !loadedPlugins.containsNames(loader.info.requiredPlugins)
@@ -160,28 +160,29 @@ internal object PluginManager : AsyncLoader<List<PluginLoader>> {
             val plugin = runCatching(loader::load).getOrElse {
                 when (it) {
                     is ClassNotFoundException -> {
-                        PluginError.log("Main class not found in plugin $loader", it)
+                        PluginError.log("Main class not found in plugin $loader", throwable = it)
                     }
                     is IllegalAccessException -> {
-                        PluginError.log(it.message, it)
+                        PluginError.log(it.message, throwable = it)
                     }
                     else -> {
-                        PluginError.log("Failed to load plugin $loader", it)
+                        PluginError.log("Failed to load plugin $loader", throwable = it)
                     }
                 }
                 return
             }
 
+            val hotReload = plugin.mixins.isEmpty()
             try {
                 plugin.onLoad()
             } catch (e: NoSuchFieldError) {
-                PluginError.log("Failed to load plugin $loader (NoSuchFieldError)", e)
+                PluginError.log("Failed to load plugin $loader (NoSuchFieldError)", hotReload, e)
                 return
             } catch (e: NoSuchMethodError) {
-                PluginError.log("Failed to load plugin $loader (NoSuchMethodError)", e)
+                PluginError.log("Failed to load plugin $loader (NoSuchMethodError)", hotReload, e)
                 return
             } catch (e: NoClassDefFoundError) {
-                PluginError.log("Failed to load plugin $loader (NoClassDefFoundError)", e)
+                PluginError.log("Failed to load plugin $loader (NoClassDefFoundError)", hotReload, e)
                 return
             }
 
@@ -202,22 +203,24 @@ internal object PluginManager : AsyncLoader<List<PluginLoader>> {
     }
 
     fun unloadAll() {
-        loadedPlugins.filter { it.hotReload }.forEach(PluginManager::unloadWithoutCheck)
+        loadedPlugins.filter { it.mixins.isEmpty() }.forEach(PluginManager::unloadWithoutCheck)
 
         LambdaMod.LOG.info("Unloaded all plugins!")
     }
 
-    fun unload(plugin: Plugin) {
+    fun unload(plugin: Plugin): Boolean {
         if (loadedPlugins.any { it.requiredPlugins.contains(plugin.name) }) {
             throw IllegalArgumentException("Plugin $plugin is required by another plugin!")
         }
 
-        unloadWithoutCheck(plugin)
+        return unloadWithoutCheck(plugin)
     }
 
-    private fun unloadWithoutCheck(plugin: Plugin) {
-        if (!plugin.hotReload) {
-            throw IllegalArgumentException("Plugin $plugin cannot be hot reloaded!")
+    private fun unloadWithoutCheck(plugin: Plugin): Boolean {
+        // Necessary because of plugin GUI
+        if (plugin.mixins.isNotEmpty()) {
+            PluginError.log("Plugin ${plugin.name} cannot be hot reloaded!")
+            return false
         }
 
         synchronized(this) {
@@ -234,5 +237,6 @@ internal object PluginManager : AsyncLoader<List<PluginLoader>> {
 
         LambdaMod.LOG.info("Unloaded plugin ${plugin.name} v${plugin.version}")
         MessageSendHelper.sendChatMessage("[Plugin Manager] ${LambdaClickGui.printInfo(plugin.name, plugin.version)} unloaded.")
+        return true
     }
 }

src/main/kotlin/com/lambda/client/plugin/api/Plugin.kt

@@ -32,7 +32,7 @@ open class Plugin : Nameable {
     val authors: Array<String> get() = info.authors
     val requiredPlugins: Array<String> get() = info.requiredPlugins
     val url: String get() = info.url
-    val hotReload: Boolean get() = info.hotReload
+    val mixins: Array<String> get() = info.mixins
 
     /**
      * Config for the plugin