#1125 Create infrastructure for Limbo persistence + restore 5.2 JSON storage

- Introduce configurable storage mechanism
  - LimboPersistence wraps a LimboPersistenceHandler, of which there are multiple implementations
  - Outside of the limbo.persistence package, classes only talk to LimboPersistence
  - Restore the way of persisting to JSON from 5.2 (SeparateFilePersistenceHandler)

- Add handling for stored limbo players
  - Merge any existing LimboPlayers together with the goal of only keeping one version of a LimboPlayer: there is no way for a player to be online without triggering the creation of a LimboPlayer first, so we can guarantee that the in-memory LimboPlayer is the most up-to-date, i.e. when restoring limbo data we don't have to check against the disk.
  - Create and delete LimboPlayers at the same time when LimboPlayers are added or removed from the in-memory map

- Catch all exceptions in LimboPersistence so a handler throwing an unexpected exception does not stop the limbo process (#1070)

- Extend debug command /authme debug limbo to show LimboPlayer information on disk, too

Author: ljacqu

.checkstyle.xml

@@ -159,6 +159,7 @@
         <module name="EmptyCatchBlock">
             <property name="exceptionVariableName" value="ignore|ignored"/>
         </module>
+        <module name="MissingOverride"/>
     </module>
     <module name="FileTabCharacter"/>
 </module>

src/main/java/fr/xephi/authme/command/executable/authme/debug/DebugCommand.java

@@ -6,10 +6,10 @@
 import org.bukkit.command.CommandSender;
 
 import javax.inject.Inject;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
 
 /**
  * Debug command main.
@@ -47,7 +47,7 @@ private DebugSection getDebugSection(List<String> arguments) {
     // Lazy getter
     private Map<String, DebugSection> getSections() {
         if (sections == null) {
-            Map<String, DebugSection> sections = new HashMap<>();
+            Map<String, DebugSection> sections = new TreeMap<>();
             for (Class<? extends DebugSection> sectionClass : sectionClasses) {
                 DebugSection section = debugSectionFactory.newInstance(sectionClass);
                 sections.put(section.getName(), section);

src/main/java/fr/xephi/authme/command/executable/authme/debug/LimboPlayerViewer.java

@@ -3,6 +3,7 @@
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.data.limbo.LimboPlayer;
 import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
 import fr.xephi.authme.service.BukkitService;
 import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
@@ -27,6 +28,9 @@ class LimboPlayerViewer implements DebugSection {
     @Inject
     private LimboService limboService;
 
+    @Inject
+    private LimboPersistence limboPersistence;
+
     @Inject
     private BukkitService bukkitService;
 
@@ -50,22 +54,23 @@ public void execute(CommandSender sender, List<String> arguments) {
             return;
         }
 
-        LimboPlayer limbo = limboService.getLimboPlayer(arguments.get(0));
+        LimboPlayer memoryLimbo = limboService.getLimboPlayer(arguments.get(0));
         Player player = bukkitService.getPlayerExact(arguments.get(0));
-        if (limbo == null && player == null) {
+        LimboPlayer diskLimbo = player != null ? limboPersistence.getLimboPlayer(player) : null;
+        if (memoryLimbo == null && player == null) {
             sender.sendMessage("No limbo info and no player online with name '" + arguments.get(0) + "'");
             return;
         }
 
-        sender.sendMessage(ChatColor.GOLD + "Showing limbo / player info for '" + arguments.get(0) + "'");
-        new InfoDisplayer(sender, limbo, player)
+        sender.sendMessage(ChatColor.GOLD + "Showing disk limbo / limbo / player info for '" + arguments.get(0) + "'");
+        new InfoDisplayer(sender, diskLimbo, memoryLimbo, player)
             .sendEntry("Is op", LimboPlayer::isOperator, Player::isOp)
             .sendEntry("Walk speed", LimboPlayer::getWalkSpeed, Player::getWalkSpeed)
             .sendEntry("Can fly", LimboPlayer::isCanFly, Player::getAllowFlight)
             .sendEntry("Fly speed", LimboPlayer::getFlySpeed, Player::getFlySpeed)
             .sendEntry("Location", l -> formatLocation(l.getLocation()), p -> formatLocation(p.getLocation()))
             .sendEntry("Group", LimboPlayer::getGroup, p -> "");
-        sender.sendMessage("Note: group is only shown for LimboPlayer");
+        sender.sendMessage("Note: group is not shown for Player. Use /authme debug groups");
     }
 
     /**
@@ -102,25 +107,30 @@ private Set<String> getLimboKeys() {
      */
     private static final class InfoDisplayer {
         private final CommandSender sender;
-        private final Optional<LimboPlayer> limbo;
+        private final Optional<LimboPlayer> diskLimbo;
+        private final Optional<LimboPlayer> memoryLimbo;
         private final Optional<Player> player;
 
         /**
          * Constructor.
          *
          * @param sender command sender to send the information to
-         * @param limbo the limbo player to get data from
+         * @param memoryLimbo the limbo player to get data from
          * @param player the player to get data from
          */
-        InfoDisplayer(CommandSender sender, LimboPlayer limbo, Player player) {
+        InfoDisplayer(CommandSender sender, LimboPlayer diskLimbo, LimboPlayer memoryLimbo, Player player) {
             this.sender = sender;
-            this.limbo = Optional.ofNullable(limbo);
+            this.diskLimbo = Optional.ofNullable(diskLimbo);
+            this.memoryLimbo = Optional.ofNullable(memoryLimbo);
             this.player = Optional.ofNullable(player);
 
-            if (limbo == null) {
+            if (memoryLimbo == null) {
                 sender.sendMessage("Note: no Limbo information available");
-            } else if (player == null) {
+            }
+            if (player == null) {
                 sender.sendMessage("Note: player is not online");
+            } else if (diskLimbo == null) {
+                sender.sendMessage("Note: no Limbo on disk available");
             }
         }
 
@@ -138,10 +148,16 @@ <T> InfoDisplayer sendEntry(String title,
                                     Function<Player, T> playerGetter) {
             sender.sendMessage(
                 title + ": "
-                + limbo.map(limboGetter).map(String::valueOf).orElse("--")
+                + getData(diskLimbo, limboGetter)
                 + " / "
-                + player.map(playerGetter).map(String::valueOf).orElse("--"));
+                + getData(memoryLimbo, limboGetter)
+                + " / "
+                + getData(player, playerGetter));
             return this;
         }
+
+        static <E, T> String getData(Optional<E> entity, Function<E, T> getter) {
+            return entity.map(getter).map(String::valueOf).orElse(" -- ");
+        }
     }
 }

src/main/java/fr/xephi/authme/data/limbo/LimboService.java

@@ -1,6 +1,7 @@
 package fr.xephi.authme.data.limbo;
 
 import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
 import fr.xephi.authme.settings.Settings;
 import org.bukkit.entity.Player;
 
@@ -28,7 +29,10 @@ public class LimboService {
     private LimboPlayerTaskManager taskManager;
 
     @Inject
-    private LimboServiceHelper limboServiceHelper;
+    private LimboServiceHelper helper;
+
+    @Inject
+    private LimboPersistence persistence;
 
     LimboService() {
     }
@@ -42,19 +46,25 @@ public class LimboService {
     public void createLimboPlayer(Player player, boolean isRegistered) {
         final String name = player.getName().toLowerCase();
 
+        LimboPlayer limboFromDisk = persistence.getLimboPlayer(player);
+        if (limboFromDisk != null) {
+            ConsoleLogger.debug("LimboPlayer for `{0}` already exists on disk", name);
+        }
+
         LimboPlayer existingLimbo = entries.remove(name);
         if (existingLimbo != null) {
             existingLimbo.clearTasks();
-            ConsoleLogger.debug("LimboPlayer for `{0}` was already present", name);
+            ConsoleLogger.debug("LimboPlayer for `{0}` already present in memory", name);
         }
 
-        LimboPlayer limboPlayer = limboServiceHelper.merge(
-            limboServiceHelper.createLimboPlayer(player, isRegistered), existingLimbo);
+        LimboPlayer limboPlayer = helper.merge(existingLimbo, limboFromDisk);
+        limboPlayer = helper.merge(helper.createLimboPlayer(player, isRegistered), limboPlayer);
 
         taskManager.registerMessageTask(player, limboPlayer, isRegistered);
         taskManager.registerTimeoutTask(player, limboPlayer);
-        limboServiceHelper.revokeLimboStates(player);
+        helper.revokeLimboStates(player);
         entries.put(name, limboPlayer);
+        persistence.saveLimboPlayer(player, limboPlayer);
     }
 
     /**
@@ -98,6 +108,7 @@ public void restoreData(Player player) {
             settings.getProperty(RESTORE_WALK_SPEED).restoreWalkSpeed(player, limbo);
             limbo.clearTasks();
             ConsoleLogger.debug("Restored LimboPlayer stats for `{0}`", lowerName);
+            persistence.removeLimboPlayer(player);
         }
     }
 

src/main/java/fr/xephi/authme/data/limbo/LimboServiceHelper.java

@@ -69,8 +69,7 @@ void revokeLimboStates(Player player) {
      * <ul>
      *  <li><code>isOperator, allowFlight</code>: true if either limbo has true</li>
      *  <li><code>flySpeed, walkSpeed</code>: maximum value of either limbo player</li>
-     *  <li><code>group</code>: from old limbo if not empty, otherwise from new limbo</li>
-     *  <li><code>location</code>: from old limbo</li>
+     *  <li><code>group, location</code>: from old limbo if not empty/null, otherwise from new limbo</li>
      * </ul>
      *
      * @param newLimbo the new limbo player
@@ -89,8 +88,9 @@ LimboPlayer merge(LimboPlayer newLimbo, LimboPlayer oldLimbo) {
         float flySpeed = Math.max(newLimbo.getFlySpeed(), oldLimbo.getFlySpeed());
         float walkSpeed = Math.max(newLimbo.getWalkSpeed(), oldLimbo.getWalkSpeed());
         String group = firstNotEmpty(newLimbo.getGroup(), oldLimbo.getGroup());
+        Location location = firstNotNull(oldLimbo.getLocation(), newLimbo.getLocation());
 
-        return new LimboPlayer(oldLimbo.getLocation(), isOperator, group, canFly, walkSpeed, flySpeed);
+        return new LimboPlayer(location, isOperator, group, canFly, walkSpeed, flySpeed);
     }
 
     private static String firstNotEmpty(String newGroup, String oldGroup) {
@@ -100,4 +100,8 @@ private static String firstNotEmpty(String newGroup, String oldGroup) {
         }
         return oldGroup;
     }
+
+    private static Location firstNotNull(Location first, Location second) {
+        return first == null ? second : first;
+    }
 }

src/main/java/fr/xephi/authme/data/limbo/persistence/LimboPersistence.java

@@ -0,0 +1,82 @@
+package fr.xephi.authme.data.limbo.persistence;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.data.limbo.LimboPlayer;
+import fr.xephi.authme.initialization.SettingsDependent;
+import fr.xephi.authme.initialization.factory.Factory;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.LimboSettings;
+import org.bukkit.entity.Player;
+
+import javax.inject.Inject;
+
+/**
+ * Handles the persistence of LimboPlayers.
+ */
+public class LimboPersistence implements SettingsDependent {
+
+    private final Factory<LimboPersistenceHandler> handlerFactory;
+
+    private LimboPersistenceHandler handler;
+
+    @Inject
+    LimboPersistence(Settings settings, Factory<LimboPersistenceHandler> handlerFactory) {
+        this.handlerFactory = handlerFactory;
+        reload(settings);
+    }
+
+    /**
+     * Retrieves the LimboPlayer for the given player if available.
+     *
+     * @param player the player to retrieve the LimboPlayer for
+     * @return the player's limbo player, or null if not available
+     */
+    public LimboPlayer getLimboPlayer(Player player) {
+        try {
+            return handler.getLimboPlayer(player);
+        } catch (Exception e) {
+            ConsoleLogger.logException("Could not get LimboPlayer for '" + player.getName() + "'", e);
+        }
+        return null;
+    }
+
+    /**
+     * Saves the given LimboPlayer for the provided player.
+     *
+     * @param player the player to save the LimboPlayer for
+     * @param limbo the limbo player to save
+     */
+    public void saveLimboPlayer(Player player, LimboPlayer limbo) {
+        try {
+            handler.saveLimboPlayer(player, limbo);
+        } catch (Exception e) {
+            ConsoleLogger.logException("Could not save LimboPlayer for '" + player.getName() + "'", e);
+        }
+    }
+
+    /**
+     * Removes the LimboPlayer for the given player.
+     *
+     * @param player the player whose LimboPlayer should be removed
+     */
+    public void removeLimboPlayer(Player player) {
+        try {
+            handler.removeLimboPlayer(player);
+        } catch (Exception e) {
+            ConsoleLogger.logException("Could not remove LimboPlayer for '" + player.getName() + "'", e);
+        }
+    }
+
+    @Override
+    public void reload(Settings settings) {
+        LimboPersistenceType persistenceType = settings.getProperty(LimboSettings.LIMBO_PERSISTENCE_TYPE);
+        if (handler == null || handler.getType() != persistenceType) {
+            // If we're changing from an existing handler, output a quick hint that nothing is converted.
+            if (handler != null) {
+                ConsoleLogger.info("Limbo persistence type has changed! Note that the data is not converted.");
+            }
+
+            handler = handlerFactory.newInstance(persistenceType.getImplementationClass());
+        }
+    }
+}

src/main/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceHandler.java

@@ -0,0 +1,39 @@
+package fr.xephi.authme.data.limbo.persistence;
+
+import fr.xephi.authme.data.limbo.LimboPlayer;
+import org.bukkit.entity.Player;
+
+/**
+ * Handles I/O for storing LimboPlayer objects.
+ */
+interface LimboPersistenceHandler {
+
+    /**
+     * Returns the limbo player for the given player if it exists.
+     *
+     * @param player the player
+     * @return the stored limbo player, or null if not available
+     */
+    LimboPlayer getLimboPlayer(Player player);
+
+    /**
+     * Saves the given limbo player for the given player to the disk.
+     *
+     * @param player the player to save the limbo player for
+     * @param limbo the limbo player to save
+     */
+    void saveLimboPlayer(Player player, LimboPlayer limbo);
+
+    /**
+     * Removes the limbo player from the disk.
+     *
+     * @param player the player whose limbo player should be removed
+     */
+    void removeLimboPlayer(Player player);
+
+    /**
+     * @return the type of the limbo persistence implementation
+     */
+    LimboPersistenceType getType();
+
+}

src/main/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceType.java

@@ -0,0 +1,29 @@
+package fr.xephi.authme.data.limbo.persistence;
+
+/**
+ * Types of persistence for LimboPlayer objects.
+ */
+public enum LimboPersistenceType {
+
+    INDIVIDUAL_FILES(SeparateFilePersistenceHandler.class),
+
+    DISABLED(NoOpPersistenceHandler.class);
+
+    private final Class<? extends LimboPersistenceHandler> implementationClass;
+
+    /**
+     * Constructor.
+     *
+     * @param implementationClass the implementation class
+     */
+    LimboPersistenceType(Class<? extends LimboPersistenceHandler> implementationClass) {
+        this.implementationClass=  implementationClass;
+    }
+
+    /**
+     * @return class implementing the persistence type
+     */
+    public Class<? extends LimboPersistenceHandler> getImplementationClass() {
+        return implementationClass;
+    }
+}