Keep FlatFile players unloaded when their data cannot be read at login

When a player's profile did not load at login, the loading task asked the
database for a new user. On FlatFile, newUser(Player) always returned a loaded
profile at starting levels, and saveUser writes over any row with that
player's UUID. A users file that could not be read at that moment, or a row
whose cooldowns could not be parsed, therefore wiped the player's stored
progress on the first save.

newUser(Player) now reads mcmmo.users and only returns a loaded profile when
the file was read and has no row with the player's UUID. Otherwise the profile
stays unloaded and the login keeps retrying the load, the same way the SQL
database behaves when its insert fails.

newUser(String, UUID) no longer appends a second row for a UUID that is
already stored. The load queries skip a row that fails to parse and use the
next row with the same UUID, so a fresh duplicate would be loaded in place of
a damaged original and then saved over both.

A row that fails to parse is now logged once per player, naming them, instead
of the exception being swallowed. Rows that end before the newer XP columns
load with those columns at zero, as the startup health check pads them,
instead of failing to load.

Author: nossr50

Changelog.txt

@@ -1,15 +1,17 @@
 Version 2.3.002
     Fixed mcMMO failing to start on Spigot 26.3 servers
     Fixed a read error while updating the FlatFile database overwriting mcmmo.users with only the players read before the error (Thanks cyrne1-7208)
+    Fixed FlatFile players losing their progress when their data could not be read as they joined (See notes)
     Fixed FlatFile database saves reporting success when mcmmo.users could not be written
     Improved performance of repairing items on an anvil
     Lowered the default Pale_Hanging_Moss XP for Herbalism in experience.yml (See notes)
-    (API) DatabaseManager.newUser(String, UUID) on the FlatFile database now returns an unloaded profile when mcmmo.users cannot be read, matching the SQL database
+    (API) DatabaseManager.newUser(Player) and newUser(String, UUID) on the FlatFile database now return an unloaded profile when mcmmo.users cannot be read or already has a row with that UUID
     (Codebase) Crossbow ricochet reflection no longer modifies the arrow velocity and block face normal vectors it is given (Thanks cyrne1-7208)
 
     NOTES:
     We believe this is a bug in Spigot 26.3 rather than an intended API change, the error comes from Spigot itself whenever a plugin looks through the server's recipes. mcMMO now works around it on our side so it keeps running until Spigot fixes it.
     If you run Spigot 26.3 you need this update, no config changes are required.
+    A FlatFile player no longer starts over with a new profile when mcmmo.users can't be read as they join, or when their row in it can't be loaded. mcMMO keeps retrying the load instead, and a damaged row is logged once with the player's name. Restarting the server repairs a damaged row by resetting the values that can't be read. This never affected SQL databases, SQL already keeps the player unloaded and retries the load in this situation.
     To get the lower Pale_Hanging_Moss XP, set 'Experience_Values.Herbalism.Pale_Hanging_Moss' to 1 in experience.yml, or delete experience.yml to generate a new one.
 
 Version 2.3.001

src/main/java/com/gmail/nossr50/database/FlatFileDatabaseManager.java

@@ -28,8 +28,10 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.TreeSet;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -57,6 +59,7 @@ public final class FlatFileDatabaseManager implements DatabaseManager {
     // check-then-act window and performing duplicate full-file scans. Only a successful rebuild
     // keeps the claimed timestamp; failures roll it back so retries are not throttled.
     private final @NotNull AtomicLong lastUpdate = new AtomicLong(0L);
+    private final @NotNull Set<UUID> reportedUnloadableRows = ConcurrentHashMap.newKeySet();
 
     private final @NotNull String usersFilePath;
     private final @NotNull File usersFile;
@@ -540,8 +543,45 @@ public void writeUserToLine(@NotNull PlayerProfile profile,
         out.append(LINE_ENDING);
     }
 
+    /**
+     * Called when the player's profile did not load. The profile returned here is saved over
+     * their stored row, so it is only loaded when the file was read and has no row with their
+     * UUID. Otherwise it is unloaded, and the login retries the load.
+     */
     public @NotNull PlayerProfile newUser(@NotNull Player player) {
-        return new PlayerProfile(player.getName(), player.getUniqueId(), true, startingLevel);
+        final UUID uuid = player.getUniqueId();
+        return new PlayerProfile(player.getName(), uuid, isConfirmedNewPlayer(uuid),
+                startingLevel);
+    }
+
+    /** True only when the users file was read and has no row for {@code uuid}. */
+    private boolean isConfirmedNewPlayer(@NotNull UUID uuid) {
+        synchronized (fileWritingLock) {
+            try (BufferedReader in = newBufferedReader()) {
+                String line;
+                while ((line = in.readLine()) != null) {
+                    if (isRowFor(line, uuid)) {
+                        return false;
+                    }
+                }
+                return true;
+            } catch (IOException e) {
+                logger.severe("Could not read " + usersFilePath + " to look for " + uuid + ": "
+                        + e);
+                return false;
+            }
+        }
+    }
+
+    /** Whether {@code line} is a row for {@code uuid}, matched the way the load queries match. */
+    private boolean isRowFor(@NotNull String line, @NotNull UUID uuid) {
+        if (line.startsWith("#")) {
+            return false;
+        }
+
+        // Nothing past the UUID is needed, so the rest of the row stays unsplit
+        final String[] fields = line.split(":", UUID_INDEX + 2);
+        return fields.length > UUID_INDEX && uuid.equals(parseUuidOrNull(fields[UUID_INDEX]));
     }
 
     public @NotNull PlayerProfile newUser(@NotNull String playerName, @NotNull UUID uuid) {
@@ -553,6 +593,13 @@ public void writeUserToLine(@NotNull PlayerProfile profile,
             try (BufferedReader bufferedReader = newBufferedReader()) {
                 String line;
                 while ((line = bufferedReader.readLine()) != null) {
+                    // A second row would be loaded instead of a first that fails to parse,
+                    // and the next save would overwrite both
+                    if (isRowFor(line, uuid)) {
+                        logger.warning("Not adding " + playerName + " (" + uuid + ") to "
+                                + usersFilePath + ", it already has a row for that UUID");
+                        return new PlayerProfile(playerName, uuid, false, startingLevel);
+                    }
                     stringBuilder.append(line).append(LINE_ENDING);
                 }
             } catch (IOException e) {
@@ -653,17 +700,15 @@ public void writeUserToLine(@NotNull PlayerProfile profile,
 
                     String[] rawSplitData = line.split(":");
 
-                    if (rawSplitData.length < (UUID_INDEX + 1)) {
+                    if (rawSplitData.length < (UUID_INDEX + 1)
+                            || !uuid.equals(parseUuidOrNull(rawSplitData[UUID_INDEX]))) {
                         continue;
                     }
 
                     try {
-                        UUID fromDataUUID = UUID.fromString(rawSplitData[UUID_INDEX]);
-                        if (fromDataUUID.equals(uuid)) {
-                            return loadFromLine(rawSplitData);
-                        }
-                    } catch (Exception e) {
-                        // Ignore malformed UUIDs
+                        return loadFromLine(rawSplitData);
+                    } catch (RuntimeException e) {
+                        logUnloadableRow(rawSplitData[USERNAME_INDEX], uuid, e);
                     }
                 }
             } catch (Exception e) {
@@ -690,28 +735,25 @@ public void writeUserToLine(@NotNull PlayerProfile profile,
 
                     String[] rawSplitData = line.split(":");
 
-                    if (rawSplitData.length < (UUID_INDEX + 1)) {
+                    if (rawSplitData.length < (UUID_INDEX + 1)
+                            || !uuid.equals(parseUuidOrNull(rawSplitData[UUID_INDEX]))) {
                         continue;
                     }
 
+                    final String dbPlayerName = rawSplitData[USERNAME_INDEX];
+                    final boolean matchingName = dbPlayerName.equalsIgnoreCase(playerName);
+
+                    if (!matchingName) {
+                        logger.warning("When loading user: " + playerName + " with UUID of ("
+                                + uuid + ") we found a mismatched name, the name in the DB will"
+                                + " be replaced (DB name: " + dbPlayerName + ")");
+                        rawSplitData[USERNAME_INDEX] = playerName;
+                    }
+
                     try {
-                        UUID fromDataUUID = UUID.fromString(rawSplitData[UUID_INDEX]);
-                        if (fromDataUUID.equals(uuid)) {
-                            String dbPlayerName = rawSplitData[USERNAME_INDEX];
-                            boolean matchingName = dbPlayerName.equalsIgnoreCase(playerName);
-
-                            if (!matchingName) {
-                                logger.warning(
-                                        "When loading user: " + playerName + " with UUID of ("
-                                                + uuid + ") we found a mismatched name, the name in the DB will be replaced (DB name: "
-                                                + dbPlayerName + ")");
-                                rawSplitData[USERNAME_INDEX] = playerName;
-                            }
-
-                            return loadFromLine(rawSplitData);
-                        }
-                    } catch (Exception e) {
-                        // Ignore malformed UUIDs
+                        return loadFromLine(rawSplitData);
+                    } catch (RuntimeException e) {
+                        logUnloadableRow(playerName, uuid, e);
                     }
                 }
             } catch (IOException e) {
@@ -723,6 +765,21 @@ public void writeUserToLine(@NotNull PlayerProfile profile,
         return grabUnloadedProfile(uuid, playerName);
     }
 
+    /**
+     * Logged once per player, since the login retries and API lookups repeat the load. Callers
+     * keep scanning afterwards, as a later row for the same player may still load.
+     */
+    private void logUnloadableRow(@NotNull String playerName, @NotNull UUID uuid,
+            @NotNull RuntimeException cause) {
+        if (!reportedUnloadableRows.add(uuid)) {
+            return;
+        }
+
+        logger.log(Level.SEVERE, "Could not load " + playerName + " (" + uuid + ") from "
+                + usersFilePath + ", their row has data that cannot be read. They will not"
+                + " load until it is fixed, restarting the server repairs it.", cause);
+    }
+
     private @NotNull PlayerProfile grabUnloadedProfile(@NotNull UUID uuid,
             @Nullable String playerName) {
         String name = (playerName == null) ? "" : playerName;
@@ -1221,6 +1278,8 @@ private void tryLoadSkillFloatValuesFromRawData(@NotNull Map<PrimarySkillType, F
         try {
             float valueFromString = Integer.parseInt(character[index]);
             skillMap.put(primarySkillType, valueFromString);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            skillMap.put(primarySkillType, 0F);
         } catch (NumberFormatException e) {
             skillMap.put(primarySkillType, 0F);
             logger.severe("Data corruption when trying to load the value for skill "