Implement PluginManager & Plugin

pom.xml

@@ -145,7 +145,7 @@
         <dependency>
             <groupId>it.unimi.dsi</groupId>
             <artifactId>fastutil</artifactId>
-            <version>8.5.12</version>
+            <version>8.5.13</version>
             <scope>compile</scope>
         </dependency>
         <dependency>

src/main/java/org/sculk/Server.java

@@ -19,9 +19,9 @@
 import org.sculk.network.Network;
 import org.sculk.network.SourceInterface;
 import org.sculk.network.protocol.ProtocolInfo;
+import org.sculk.plugin.PluginManager;
 import org.sculk.scheduler.Scheduler;
 import org.sculk.utils.TextFormat;
-import org.sculk.utils.Utils;
 
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
@@ -55,6 +55,7 @@ public class Server {
     private final Logger logger;
     private final TerminalConsole console;
     private final EventManager eventManager;
+    private final PluginManager pluginManager;
     private final Injector injector;
     private Scheduler scheduler;
 
@@ -111,6 +112,7 @@ public Server(Logger logger, String dataPath) {
         this.injector = Guice.createInjector(Stage.PRODUCTION, new SculkModule(this));
         this.eventManager = injector.getInstance(EventManager.class);
         this.scheduler = injector.getInstance(Scheduler.class);
+        this.pluginManager = new PluginManager(this);
 
         this.operators = new Config(this.dataPath.resolve("op.txt").toString(), Config.ENUM);
         this.whitelist = new Config(this.dataPath.resolve("whitelist.txt").toString(), Config.ENUM);
@@ -127,6 +129,10 @@ public Server(Logger logger, String dataPath) {
     public void start() {
         this.console.getConsoleThread().start();
 
+        logger.info("Loading all plugins...");
+        pluginManager.loadAllPlugins();
+        logger.info("All plugins loaded successfully");
+
         InetSocketAddress bindAddress = new InetSocketAddress(this.getProperties().get(ServerPropertiesKeys.SERVER_IP, "0.0.0.0"), this.getProperties().get(ServerPropertiesKeys.SERVER_PORT, 19132));
         this.serverId = UUID.randomUUID();
         this.network = new Network(this);
@@ -150,6 +156,10 @@ public void start() {
         logger.info("This server is running on version {}",TextFormat.AQUA + Sculk.CODE_VERSION);
         logger.info("Sculk is distributed undex the {}",TextFormat.AQUA + "GNU GENERAL PUBLIC LICENSE");
 
+        logger.info("Enable all plugins...");
+        pluginManager.enableAllPlugins();
+        logger.info("All plugins enabled successfully");
+
         getLogger().info("Done ({}s)! For help, type \"help\" or \"?", (double) (System.currentTimeMillis() - Sculk.START_TIME) / 1000);
         this.tickProcessor();
     }
@@ -161,6 +171,10 @@ public void shutdown() {
         this.logger.info("Stopping the server");
         this.shutdown = true;
 
+        logger.info("Disabling all plugins...");
+        pluginManager.disableAllPlugins();
+        logger.info("Disabled all plugins");
+
         Sculk.shutdown();
 
         this.logger.info("Stopping network interfaces");
@@ -180,6 +194,10 @@ public EventManager getEventManager() {
         return eventManager;
     }
 
+    public PluginManager getPluginManager() {
+        return pluginManager;
+    }
+
     public Injector getInjector() {
         return injector;
     }

src/main/java/org/sculk/plugin/Plugin.java

@@ -0,0 +1,96 @@
+package org.sculk.plugin;
+
+import com.google.common.base.Preconditions;
+import org.apache.logging.log4j.Logger;
+import org.sculk.Server;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public abstract class Plugin {
+    protected boolean enabled = false;
+    private PluginData description;
+    private Server server;
+    private Logger logger;
+    private File pluginFile;
+    private File dataFolder;
+    private boolean initialized = false;
+
+    public Plugin() {
+    }
+
+    protected final void init(PluginData description, Server server, File pluginFile) {
+        Preconditions.checkArgument(!this.initialized, "Plugin has been already initialized!");
+        this.initialized = true;
+        this.description = description;
+        this.server = server;
+        this.logger = server.getLogger();
+
+        this.pluginFile = pluginFile;
+        this.dataFolder = new File(Server.getInstance().getDataPath() + "/plugins/" + description.getName().toLowerCase() + "/");
+        if (!this.dataFolder.exists()) {
+            this.dataFolder.mkdirs();
+        }
+    }
+
+    public void onLoad() {
+    }
+
+    public abstract void onEnable();
+
+    public void onDisable() {
+    }
+
+    public InputStream getResourceFile(String filename) {
+        try {
+            JarFile pluginJar = new JarFile(this.pluginFile);
+            JarEntry entry = pluginJar.getJarEntry(filename);
+            return pluginJar.getInputStream(entry);
+        } catch (IOException e) {
+        }
+        return null;
+    }
+
+    public boolean isEnabled() {
+        return this.enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        if (this.enabled == enabled) {
+            return;
+        }
+        this.enabled = enabled;
+        try {
+            if (enabled) {
+                this.onEnable();
+            } else {
+                this.onDisable();
+            }
+        } catch (Exception e) {
+            this.logger.error("Error while enabling/disabling plugin " + this.getName() + ": " + e);
+        }
+    }
+
+    public PluginData getDescription() {
+        return this.description;
+    }
+
+    public String getName() {
+        return this.description.getName();
+    }
+
+    public Server getServer() {
+        return this.server;
+    }
+
+    public Logger getLogger() {
+        return this.logger;
+    }
+
+    public File getDataFolder() {
+        return this.dataFolder;
+    }
+}

src/main/java/org/sculk/plugin/PluginClassLoader.java

@@ -0,0 +1,42 @@
+package org.sculk.plugin;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+public class PluginClassLoader extends URLClassLoader {
+
+    private final PluginManager pluginManager;
+    private final Object2ObjectOpenHashMap<String, Class<?>> classes = new Object2ObjectOpenHashMap<>();
+
+    public PluginClassLoader(PluginManager pluginManager, ClassLoader parent, File file) throws MalformedURLException {
+        super(new URL[]{file.toURI().toURL()}, parent);
+        this.pluginManager = pluginManager;
+    }
+
+    @Override
+    protected Class<?> findClass(String name) throws ClassNotFoundException {
+        return this.findClass(name, true);
+    }
+
+    protected Class<?> findClass(String name, boolean checkGlobal) throws ClassNotFoundException {
+        Class<?> result = this.classes.get(name);
+        if (result != null) {
+            return result;
+        }
+
+        if (checkGlobal) {
+            result = this.pluginManager.getClassFromCache(name);
+        }
+
+        if (result == null && (result = super.findClass(name)) != null) {
+            this.pluginManager.cacheClass(name, result);
+        }
+        this.classes.put(name, result);
+        return result;
+    }
+
+}

src/main/java/org/sculk/plugin/PluginData.java

@@ -0,0 +1,35 @@
+package org.sculk.plugin;
+
+import lombok.ToString;
+
+import java.util.List;
+
+@ToString
+public class PluginData{
+
+    public String name;
+    public String version;
+    public String author;
+    public String main;
+    public List<String> depends;
+
+    public String getAuthor() {
+        return this.author;
+    }
+
+    public String getMain() {
+        return this.main;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getVersion() {
+        return this.version;
+    }
+
+    public List<String> getDepends() {
+        return this.depends;
+    }
+}

src/main/java/org/sculk/plugin/PluginLoader.java

@@ -0,0 +1,77 @@
+package org.sculk.plugin;
+
+import lombok.extern.log4j.Log4j2;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.File;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.nio.file.Path;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+@Log4j2
+public class PluginLoader {
+
+    private final PluginManager pluginManager;
+
+    public PluginLoader(PluginManager pluginManager) {
+        this.pluginManager = pluginManager;
+    }
+
+    protected static boolean isJarFile(Path file) {
+        return file.getFileName().toString().endsWith(".jar");
+    }
+
+    protected PluginClassLoader loadClassLoader(PluginData pluginConfig, File pluginJar) {
+        try {
+            return new PluginClassLoader(this.pluginManager, this.getClass().getClassLoader(), pluginJar);
+        } catch (MalformedURLException e) {
+            log.error("Error while creating class loader(plugin={})", pluginConfig.getName());
+        }
+        return null;
+    }
+
+    protected Plugin loadPluginJAR(PluginData pluginConfig, File pluginJar, PluginClassLoader loader) {
+        try {
+            Class<?> mainClass = loader.loadClass(pluginConfig.getMain());
+            if (!Plugin.class.isAssignableFrom(mainClass)) {
+                return null;
+            }
+
+            Class<? extends Plugin> castedMain = mainClass.asSubclass(Plugin.class);
+            Plugin plugin = castedMain.getDeclaredConstructor().newInstance();
+            plugin.init(pluginConfig, this.pluginManager.getServer(), pluginJar);
+            return plugin;
+        } catch (Exception e) {
+            log.error("Error while loading plugin main class(main={}, plugin={})", pluginConfig.getMain(), pluginConfig.getName(), e);
+        }
+        return null;
+    }
+
+    protected PluginData loadPluginData(File file, Yaml yaml) {
+        try (JarFile pluginJar = new JarFile(file)) {
+            JarEntry configEntry = pluginJar.getJarEntry("redstonecloud.yml");
+            if (configEntry == null) {
+                configEntry = pluginJar.getJarEntry("plugin.yml");
+            }
+
+            if (configEntry == null) {
+                log.warn("Jar file " + file.getName() + " doesnt contain a waterdog.yml or plugin.yml!");
+                return null;
+            }
+
+            try (InputStream fileStream = pluginJar.getInputStream(configEntry)) {
+                PluginData pluginConfig = yaml.loadAs(fileStream, PluginData.class);
+                if (pluginConfig.getMain() != null && pluginConfig.getName() != null) {
+                    // Valid plugin.yml, main and name set
+                    return pluginConfig;
+                }
+            }
+            log.warn("Invalid plugin.yml for " + file.getName() + ": main and/or name property missing");
+        } catch (Exception e) {
+            log.error("Can not load plugin files in " + file.getPath(), e);
+        }
+        return null;
+    }
+}