Update injector version and move shutdown logic to separate classes

src/main/java/fr/xephi/authme/initialization/Initializer.java

@@ -37,7 +37,7 @@ import static fr.xephi.authme.settings.properties.EmailSettings.RECALL_PLAYERS;
 import static fr.xephi.authme.util.BukkitService.TICKS_PER_MINUTE;
 
 /**
- * Initializes the plugin's data source.
+ * Initializes various services.
  */
 public class Initializer {
 
@@ -70,6 +70,7 @@ public class Initializer {
     /**
      * Sets up the data source.
      *
+     * @param settings the settings
      * @throws ClassNotFoundException if no driver could be found for the datasource
      * @throws SQLException           when initialization of a SQL datasource failed
      * @throws IOException            if flat file cannot be read
@@ -119,6 +120,9 @@ public class Initializer {
 
     /**
      * Sets up the console filter if enabled.
+     *
+     * @param settings the settings
+     * @param logger the plugin logger
      */
     public void setupConsoleFilter(Settings settings, Logger logger) {
         if (!settings.getProperty(SecuritySettings.REMOVE_PASSWORD_FROM_CONSOLE)) {

src/main/java/fr/xephi/authme/initialization/OnShutdownPlayerSaver.java

@@ -0,0 +1,85 @@
+package fr.xephi.authme.initialization;
+
+import fr.xephi.authme.cache.auth.PlayerAuth;
+import fr.xephi.authme.cache.auth.PlayerCache;
+import fr.xephi.authme.cache.backup.PlayerDataStorage;
+import fr.xephi.authme.cache.limbo.LimboCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.hooks.PluginHooks;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.SpawnLoader;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+import fr.xephi.authme.util.BukkitService;
+import fr.xephi.authme.util.ValidationService;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+
+/**
+ * Saves all players' data when the plugin shuts down.
+ */
+public class OnShutdownPlayerSaver {
+
+    @Inject
+    private BukkitService bukkitService;
+    @Inject
+    private Settings settings;
+    @Inject
+    private ValidationService validationService;
+    @Inject
+    private LimboCache limboCache;
+    @Inject
+    private DataSource dataSource;
+    @Inject
+    private PlayerDataStorage playerDataStorage;
+    @Inject
+    private SpawnLoader spawnLoader;
+    @Inject
+    private PluginHooks pluginHooks;
+    @Inject
+    private PlayerCache playerCache;
+
+    OnShutdownPlayerSaver() {
+    }
+
+    /**
+     * Saves the data of all online players.
+     */
+    public void saveAllPlayers() {
+        for (Player player : bukkitService.getOnlinePlayers()) {
+            savePlayer(player);
+        }
+    }
+
+    private void savePlayer(Player player) {
+        final String name = player.getName().toLowerCase();
+        if (pluginHooks.isNpc(player) || validationService.isUnrestricted(name)) {
+            return;
+        }
+        if (limboCache.hasPlayerData(name)) {
+            limboCache.restoreData(player);
+            limboCache.removeFromCache(player);
+        } else {
+            saveLoggedinPlayer(player);
+        }
+        playerCache.removePlayer(name);
+    }
+
+    private void saveLoggedinPlayer(Player player) {
+        if (settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)) {
+            Location loc = spawnLoader.getPlayerLocationOrSpawn(player);
+            final PlayerAuth auth = PlayerAuth.builder()
+                .name(player.getName().toLowerCase())
+                .realName(player.getName())
+                .location(loc).build();
+            dataSource.updateQuitLoc(auth);
+        }
+        if (settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)
+            && !settings.getProperty(RestrictionSettings.NO_TELEPORT)) {
+            if (!playerDataStorage.hasData(player)) {
+                playerDataStorage.saveData(player);
+            }
+        }
+    }
+}

src/main/java/fr/xephi/authme/initialization/TaskCloser.java

@@ -0,0 +1,88 @@
+package fr.xephi.authme.initialization;
+
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.datasource.DataSource;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitWorker;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Waits for asynchronous tasks to complete before closing the data source
+ * so the plugin can shut down properly.
+ */
+public class TaskCloser implements Runnable {
+
+    private final BukkitScheduler scheduler;
+    private final Logger logger;
+    private final AuthMe plugin;
+    private final DataSource dataSource;
+
+    /**
+     * Constructor.
+     *
+     * @param plugin the plugin instance
+     * @param dataSource the data source (nullable)
+     */
+    public TaskCloser(AuthMe plugin, DataSource dataSource) {
+        this.scheduler = plugin.getServer().getScheduler();
+        this.logger = plugin.getLogger();
+        this.plugin = plugin;
+        this.dataSource = dataSource;
+    }
+
+    @Override
+    public void run() {
+        List<Integer> pendingTasks = getPendingTasks();
+        logger.log(Level.INFO, "Waiting for {0} tasks to finish", pendingTasks.size());
+        int progress = 0;
+
+        //one minute + some time checking the running state
+        int tries = 60;
+        while (!pendingTasks.isEmpty()) {
+            if (tries <= 0) {
+                logger.log(Level.INFO, "Async tasks times out after to many tries {0}", pendingTasks);
+                break;
+            }
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException ignored) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+
+            for (Iterator<Integer> iterator = pendingTasks.iterator(); iterator.hasNext(); ) {
+                int taskId = iterator.next();
+                if (!scheduler.isCurrentlyRunning(taskId)) {
+                    iterator.remove();
+                    progress++;
+                    logger.log(Level.INFO, "Progress: {0} / {1}", new Object[]{progress, pendingTasks.size()});
+                }
+            }
+
+            tries--;
+        }
+
+        if (dataSource != null) {
+            dataSource.close();
+        }
+    }
+
+    private List<Integer> getPendingTasks() {
+        List<Integer> pendingTasks = new ArrayList<>();
+        //returns only the async tasks
+        for (BukkitWorker pendingTask : scheduler.getActiveWorkers()) {
+            if (pendingTask.getOwner().equals(plugin)
+                //it's not a periodic task
+                && !scheduler.isQueued(pendingTask.getTaskId())) {
+                pendingTasks.add(pendingTask.getTaskId());
+            }
+        }
+        return pendingTasks;
+    }
+}