Some progress

Author: jamezrin

README.md

@@ -4,23 +4,20 @@
 [![Build Status](https://travis-ci.com/Jamezrin/PlayerBalancer.svg?token=2yUi9WpA9QzSbJx9eTmy&branch=master)](https://travis-ci.com/Jamezrin/PlayerBalancer)
 
 ### Things to do:
-- [x] Get dummy sections able to have already registered servers on other sections
-- [x] Add a new message for when a player gets connected to a server and repurpose the connecting one
+- [x] Get dummy sections able to have already registered serverEntries on other sections
+- [x] Add a new message for when a player gets connected to a serverName and repurpose the connecting one
 - [ ] Add support for wildcards, contains, equalsIgnoreCase and regex at the same time
-- [ ] Add option to force joining a specific section
-- [x] Add tooltip when you hover over a server in /section info
+- [ ] Add option to force joining a specific section (to the command)
+- [x] Add tooltip when you hover over a serverName in /section info
 - [ ] Stop using inventivetalent's deprecated bungee-update
 - [ ] Create a spigot addon that adds connector signs and placeholders
 - [x] Separate the types of connections in classes instead of being in ConnectionIntent
 - [ ] Make the plugin API be not so dependent on a instance of PlayerBalancer
 - [ ] Separate connection providers in classes instead of being hardcoded in an enum
-- [x] Make the feature `marker-descs` work per section
-- [ ] Add a identifier to get the servers of a section (auto complete)
+- [ ] Make the feature `marker-descs` work per section
+- [ ] Add a identifier to get the serverEntries of a section (auto complete)
 - [ ] Implement fast connect (dimension change)
 - [ ] Implement a way to redirect premium players to a section and cracked ones to other section (not sure how this works)
-- [ ] Unify the code that loads server into a section (duplicated at SectionManager and ServerSection) 
+- [ ] Unify the code that loads serverName into a section (duplicated at SectionManager and ServerSection) 
 - [ ] Unify some of the code used in the FallbackCommand and SectionCommand
-- [ ] (!) Make the section initialization work in stages instead of being hardcoded
-- [ ] (!) Ditch the faucet dependency and use [ConfigMe](https://github.com/AuthMe/ConfigMe) and [DependencyInjector](https://github.com/ljacqu/DependencyInjector) instead
-- [ ] Use a separate file for configuring the sections, must be done alongside the previous item
-- [ ] Make this repository public
+- [ ] Make the section initialization work in stages instead of being hardcoded

pom.xml

@@ -68,21 +68,6 @@
                     </execution>
                 </executions>
             </plugin>
-            <!--
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>license-maven-plugin</artifactId>
-                <version>1.13</version>
-                <executions>
-                    <execution>
-                        <id>download-licenses</id>
-                        <goals>
-                            <goal>download-licenses</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            -->
         </plugins>
         <resources>
             <resource>
@@ -98,59 +83,30 @@
             <version>1.11-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
-
-        <dependency>
-            <groupId>ch.jalu</groupId>
-            <artifactId>configme</artifactId>
-            <version>0.6-SNAPSHOT</version>
-            <scope>compile</scope>
-            <exclusions>
-                <!-- This is already shaded in BungeeCord -->
-                <exclusion>
-                    <groupId>org.yaml</groupId>
-                    <artifactId>snakeyaml</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-
-        <dependency>
-            <groupId>ch.jalu</groupId>
-            <artifactId>injector</artifactId>
-            <version>0.5-SNAPSHOT</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <!-- TODO Replace with HTTP call to Spigot's API -->
         <dependency>
             <groupId>org.inventivetalent.update</groupId>
             <artifactId>bungee</artifactId>
             <version>1.0.1</version>
             <scope>compile</scope>
         </dependency>
-
-        <!-- TODO Replace with our own alternative to "RedisBungee" (maybe) -->
         <dependency>
             <groupId>com.imaginarycode.minecraft</groupId>
             <artifactId>RedisBungee</artifactId>
             <version>0.3.8-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
-
-
+        <dependency>
+            <groupId>ninja.leaping.configurate</groupId>
+            <artifactId>configurate-hocon</artifactId>
+            <version>3.3</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>org.bstats</groupId>
             <artifactId>bstats-bungeecord</artifactId>
             <version>1.2</version>
             <scope>compile</scope>
         </dependency>
-
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.16.16</version>
-            <scope>provided</scope>
-        </dependency>
-
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>

src/main/java/com/jaimemartz/playerbalancer/PlayerBalancer.java

@@ -1,57 +1,91 @@
 package com.jaimemartz.playerbalancer;
 
-import ch.jalu.injector.Injector;
-import ch.jalu.injector.InjectorBuilder;
-import com.jaimemartz.playerbalancer.settings.Settings;
-import com.jaimemartz.playerbalancer.settings.SettingsProvider;
-import lombok.Getter;
-import net.md_5.bungee.api.ProxyServer;
+import com.google.common.reflect.TypeToken;
+import com.jaimemartz.playerbalancer.commands.FallbackCommand;
+import com.jaimemartz.playerbalancer.commands.MainCommand;
+import com.jaimemartz.playerbalancer.commands.ManageCommand;
+import com.jaimemartz.playerbalancer.connection.ServerAssignRegistry;
+import com.jaimemartz.playerbalancer.listener.*;
+import com.jaimemartz.playerbalancer.manager.NetworkManager;
+import com.jaimemartz.playerbalancer.manager.PasteHelper;
+import com.jaimemartz.playerbalancer.manager.PlayerLocker;
+import com.jaimemartz.playerbalancer.ping.StatusManager;
+import com.jaimemartz.playerbalancer.section.SectionManager;
+import com.jaimemartz.playerbalancer.section.ServerSection;
+import com.jaimemartz.playerbalancer.settings.MainSettings;
+import com.jaimemartz.playerbalancer.settings.serializers.SectionSerializer;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.api.plugin.Plugin;
+import ninja.leaping.configurate.ConfigurationOptions;
+import ninja.leaping.configurate.commented.CommentedConfigurationNode;
+import ninja.leaping.configurate.hocon.HoconConfigurationLoader;
+import ninja.leaping.configurate.loader.ConfigurationLoader;
+import ninja.leaping.configurate.objectmapping.serialize.TypeSerializerCollection;
+import ninja.leaping.configurate.objectmapping.serialize.TypeSerializers;
 import org.bstats.bungeecord.Metrics;
+import org.inventivetalent.update.bungee.BungeeUpdater;
 
-public class PlayerBalancer extends Plugin {
-    @Getter private boolean failed = false;
-
-    private Injector injector;
-    private Settings settings;
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.Level;
 
+public class PlayerBalancer extends Plugin {
+    private boolean failed = false;
+    private StatusManager statusManager;
+    private MainSettings mainSettings;
+    private ConfigurationLoader<CommentedConfigurationNode> loader;
+    private SectionManager sectionManager;
+    private NetworkManager networkManager;
     private Command fallbackCommand, mainCommand, manageCommand;
     private Listener connectListener, kickListener, messageListener, reloadListener;
 
     @Override
     public void onEnable() {
-        injector = new InjectorBuilder()
-                .addDefaultHandlers(getClass().getPackage().getName())
-                .create();
+        Metrics metrics = new Metrics(this);
+        metrics.addCustomChart(new Metrics.SingleLineChart("configured_sections", () -> sectionManager.getSections().size()));
+
+        this.enable();
+    }
 
-        injector.register(PlayerBalancer.class, this);
-        injector.register(ProxyServer.class, this.getProxy());
+    private void enable() {
+        if (!getDataFolder().exists())
+            getDataFolder().mkdir();
 
-        injector.registerProvider(Settings.class, SettingsProvider.class);
+        File file = new File(getDataFolder(), "default.conf");
 
-        settings = injector.getSingleton(Settings.class);
+        if (loader == null) {
+            TypeSerializerCollection serializers = TypeSerializers.getDefaultSerializers().newChild();
+            serializers.registerType(TypeToken.of(ServerSection.class), new SectionSerializer());
+            ConfigurationOptions options = ConfigurationOptions.defaults().setSerializers(serializers);
+            //options.setMapFactory(MapFactories.insertionOrdered());
+            loader = HoconConfigurationLoader.builder().setFile(file).setDefaultOptions(options).build();
+        }
 
-        Metrics metrics = new Metrics(this);
+        try {
+            CommentedConfigurationNode node = loader.load();
 
-        if (this.enable()) {
-            //metrics.addCustomChart(new Metrics.SingleLineChart("configured_sections", () -> s.size()));
+            if (!file.exists()) {
+                mainSettings = new MainSettings()._defaults();
+                node.setValue(TypeToken.of(MainSettings.class), mainSettings);
+                loader.save(node);
+            } else {
+                mainSettings = node.getValue(TypeToken.of(MainSettings.class));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
         }
-    }
 
-    private boolean enable() {
-        /*
         mainCommand = new MainCommand(this);
         getProxy().getPluginManager().registerCommand(this, mainCommand);
 
-        if (settings.getProperty(GeneralProperties.ENABLED)) {
-            if (settings.getProperty(GeneralProperties.SILENT)) {
+        if (mainSettings.getGeneralProps().isActive()) {
+            if (mainSettings.getGeneralProps().isSilent()) {
                 getLogger().setLevel(Level.WARNING);
             }
 
-            if (settings.getProperty(GeneralProperties.AUTO_RELOAD)) {
-                reloadListener = injector.getSingleton(ProxyReloadListener.class);
+            if (mainSettings.getGeneralProps().isAutoReload()) {
+                reloadListener = new ProxyReloadListener(this);
                 getProxy().getPluginManager().registerListener(this, reloadListener);
             }
 
@@ -61,43 +95,43 @@ private boolean enable() {
                 e.printStackTrace();
             }
 
+            networkManager = new NetworkManager(this);
             sectionManager = new SectionManager(this);
 
             try {
                 sectionManager.load();
 
-                statusManager = new StatusManager();
-                if (settings.getProperty(CheckerProperties.ENABLED)) {
-                    statusManager.start(this);
+                statusManager = new StatusManager(this);
+                if (mainSettings.getServerCheckerProps().isActive()) {
+                    statusManager.start();
                 }
 
-                if (settings.getProperty(CommandProperties.ENABLED)) {
-                    fallbackCommand = injector.getSingleton(FallbackCommand.class);
+                if (mainSettings.getFallbackCommandProps().isActive()) {
+                    fallbackCommand = new FallbackCommand(this, mainSettings.getFallbackCommandProps().getCommand());
                     getProxy().getPluginManager().registerCommand(this, fallbackCommand);
                 }
 
-                connectListener = injector.getSingleton(ServerConnectListener.class);
+                connectListener = new ServerConnectListener(this);
                 getProxy().getPluginManager().registerListener(this, connectListener);
 
-                messageListener = injector.getSingleton(PluginMessageListener.class);
+                messageListener = new PluginMessageListener(this);
                 getProxy().getPluginManager().registerListener(this, messageListener);
 
-                manageCommand = injector.getSingleton(ManageCommand.class);
+                manageCommand = new ManageCommand(this);
                 getProxy().getPluginManager().registerCommand(this, manageCommand);
 
-                getProxy().getPluginManager().registerListener(this, injector.getSingleton(PlayerDisconnectListener.class));
+                getProxy().getPluginManager().registerListener(this, new PlayerDisconnectListener(this));
 
                 getProxy().registerChannel("PlayerBalancer");
 
-                Stream.of(PasteHelper.values()).forEach(a -> a.setUrl(null));
+                PasteHelper.reset();
 
-                if (settings.getProperty(ReconnectorProperties.ENABLED)) {
-                    kickListener = injector.getSingleton(ServerKickListener.class);
+                if (mainSettings.getKickHandlerProps().isActive()) {
+                    kickListener = new ServerKickListener(this);
                     getProxy().getPluginManager().registerListener(this, kickListener);
                 }
 
                 getLogger().info("The plugin has finished loading without any problems");
-                return true;
             } catch (RuntimeException e) {
                 this.failed = true;
                 getLogger().severe("The plugin could not continue loading due to an unexpected exception");
@@ -109,8 +143,6 @@ private boolean enable() {
             getLogger().warning("Nothing is going to work until you do that, you can reload me by using the /balancer command");
             getLogger().warning("-----------------------------------------------------");
         }
-        */
-        return false;
     }
 
     @Override
@@ -119,24 +151,23 @@ public void onDisable() {
     }
 
     private void disable() {
-        /*
         getProxy().getPluginManager().unregisterCommand(mainCommand);
         mainCommand = null;
 
-        if (settings.getProperty(GeneralProperties.ENABLED)) {
+        if (mainSettings.getGeneralProps().isActive()) {
             //Do not try to do anything if the plugin has not loaded correctly
-            if (isFailed()) return;
+            if (failed) return;
 
-            if (settings.getProperty(GeneralProperties.AUTO_RELOAD)) {
+            if (mainSettings.getGeneralProps().isAutoReload()) {
                 getProxy().getPluginManager().unregisterListener(reloadListener);
                 reloadListener = null;
             }
 
-            if (settings.getProperty(CheckerProperties.ENABLED)) {
+            if (mainSettings.getServerCheckerProps().isActive()) {
                 statusManager.stop();
             }
 
-            if (settings.getProperty(CommandProperties.ENABLED)) {
+            if (mainSettings.getFallbackCommandProps().isActive()) {
                 getProxy().getPluginManager().unregisterCommand(fallbackCommand);
                 fallbackCommand = null;
             }
@@ -150,34 +181,48 @@ private void disable() {
             getProxy().getPluginManager().unregisterCommand(manageCommand);
             manageCommand = null;
 
-            if (settings.getProperty(ReconnectorProperties.ENABLED)) {
+            if (mainSettings.getKickHandlerProps().isActive()) {
                 getProxy().getPluginManager().unregisterListener(kickListener);
                 kickListener = null;
             }
 
             sectionManager.flush();
 
-            if (settings.getProperty(GeneralProperties.ASSIGN_TARGETS)) {
+            if (mainSettings.getGeneralProps().isAssignTargets()) {
                 ServerAssignRegistry.getTable().clear();
             }
         }
 
         PlayerLocker.flush();
         failed = false;
-        */
     }
 
     public boolean reloadPlugin() {
         getLogger().info("Reloading the plugin...");
         long starting = System.currentTimeMillis();
 
         this.disable();
-        settings.reload();
         this.enable();
 
         long ending = System.currentTimeMillis() - starting;
         getLogger().info(String.format("The plugin has been reloaded, took %sms", ending));
 
         return !failed;
     }
+
+    public MainSettings getSettings() {
+        return mainSettings;
+    }
+
+    public SectionManager getSectionManager() {
+        return sectionManager;
+    }
+
+    public StatusManager getStatusManager() {
+        return statusManager;
+    }
+
+    public NetworkManager getNetworkManager() {
+        return networkManager;
+    }
 }