Partial revert of unnecessary changes

Author: zombachu

src/main/java/org/mvplugins/multiverse/inventories/commands/bulkedit/playerprofile/MigrateInventorySerializationCommand.java

@@ -17,19 +17,16 @@
 import org.mvplugins.multiverse.inventories.profile.ProfileDataSource;
 import org.mvplugins.multiverse.inventories.profile.key.GlobalProfileKey;
 import org.mvplugins.multiverse.inventories.profile.key.ProfileKey;
-import org.mvplugins.multiverse.inventories.profile.key.ProfileType;
 import org.mvplugins.multiverse.inventories.profile.key.ProfileTypes;
 import org.mvplugins.multiverse.inventories.profile.key.ContainerType;
 import org.mvplugins.multiverse.inventories.profile.ProfileFilesLocator;
-import org.mvplugins.multiverse.inventories.util.ItemStackConverter;
 
 import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -62,11 +59,6 @@ final class MigrateInventorySerializationCommand extends InventoriesCommand {
     @Subcommand("bulkedit migrate inventory-serialization nbt")
     @CommandPermission("multiverse.inventories.bulkedit")
     void onNbtCommand(MVCommandIssuer issuer) {
-        if (!ItemStackConverter.hasByteSerializeSupport()) {
-            issuer.sendMessage("NBT serialization is only supported on PaperMC 1.20.2 or higher!");
-            issuer.sendMessage("Conversion to NBT is not possible on your current server version.");
-            return;
-        }
         commandQueueManager.addToQueue(CommandQueuePayload.issuer(issuer)
                 .prompt(Message.of("Are you sure you want to migrate all player data to NBT?"))
                 .action(() -> doMigration(issuer, true)));
@@ -81,35 +73,29 @@ void onBukkitCommand(MVCommandIssuer issuer) {
     }
 
     private void doMigration(MVCommandIssuer issuer, boolean useByteSerialization) {
-        issuer.sendMessage("Updating config and clearing caches...");
         inventoriesConfig.setUseByteSerializationForInventoryData(useByteSerialization);
         inventoriesConfig.save();
-        profileCacheManager.clearAllCache();
 
         long startTime = System.nanoTime();
         AtomicLong profileCounter = new AtomicLong(0);
 
-        Map<ContainerType, List<String>> containerNames = new HashMap<>();
-        for (ContainerType type : ContainerType.values()) {
-            containerNames.put(type, profileDataSource.listContainerDataNames(type));
-        }
-
-        Set<String> playerIdentifiers = new HashSet<>();
         // Scan global files
+        Set<String> fileNamesSet = new HashSet<>();
         profileFilesLocator.listGlobalFiles().forEach(file ->
-                playerIdentifiers.add(Files.getNameWithoutExtension(file.getName())));
+                fileNamesSet.add(Files.getNameWithoutExtension(file.getName())));
 
         // Scan world and group files
         for (ContainerType type : ContainerType.values()) {
             for (File folder : profileFilesLocator.listProfileContainerFolders(type)) {
                 profileFilesLocator.listPlayerProfileFiles(type, folder.getName()).forEach(file ->
-                        playerIdentifiers.add(Files.getNameWithoutExtension(file.getName())));
+                        fileNamesSet.add(Files.getNameWithoutExtension(file.getName())));
             }
         }
 
-        issuer.sendMessage("Found " + playerIdentifiers.size() + " unique player identifiers to migrate.");
+        List<String> fileNames = new ArrayList<>(fileNamesSet);
+        issuer.sendMessage("Found " + fileNames.size() + " unique players to migrate.");
 
-        migrateNextPlayer(issuer, new ArrayList<>(playerIdentifiers), 0, containerNames, profileCounter)
+        migrateNextPlayer(issuer, fileNames, 0, profileCounter)
                 .thenRun(() -> {
                     long timeDuration = (System.nanoTime() - startTime) / 1000000;
                     issuer.sendMessage("Updated " + profileCounter.get() + " player profiles.");
@@ -119,76 +105,59 @@ private void doMigration(MVCommandIssuer issuer, boolean useByteSerialization) {
 
     private CompletableFuture<Void> migrateNextPlayer(
             MVCommandIssuer issuer,
-            List<String> playerIdentifiers,
+            List<String> fileNames,
             int index,
-            Map<ContainerType, List<String>> containerNames,
             AtomicLong profileCounter
     ) {
-        if (index >= playerIdentifiers.size()) {
+        if (index >= fileNames.size()) {
             return CompletableFuture.completedFuture(null);
         }
 
-        String playerIdentifier = playerIdentifiers.get(index);
+        String fileName = fileNames.get(index);
         UUID playerUUID;
         try {
-            playerUUID = UUID.fromString(playerIdentifier);
+            playerUUID = UUID.fromString(fileName);
         } catch (IllegalArgumentException e) {
-            playerUUID = UUID.nameUUIDFromBytes(("OfflinePlayer:" + playerIdentifier).getBytes(StandardCharsets.UTF_8));
+            // Fall back to parsing it as an offline mode UUID
+            playerUUID = UUID.nameUUIDFromBytes(("OfflinePlayer:" + fileName).getBytes(StandardCharsets.UTF_8));
         }
 
-        if (index % 50 == 0 && index > 0) {
+        if (index % 100 == 0) {
             issuer.sendMessage("Processed " + index + " players...");
         }
 
-        return profileDataSource.getGlobalProfile(GlobalProfileKey.of(playerUUID, playerIdentifier))
-                .thenCompose(profile -> run(issuer, profile, containerNames, profileCounter))
+        return profileDataSource.getGlobalProfile(GlobalProfileKey.of(playerUUID, fileName))
+                .thenCompose(profile -> run(profile, profileCounter))
                 .exceptionally(throwable -> {
-                    issuer.sendMessage("Error updating player " + playerIdentifier + ": " + throwable.getMessage());
+                    issuer.sendMessage("Error updating player " + fileName + ": " + throwable.getMessage());
                     return null;
                 })
-                .thenCompose(v -> migrateNextPlayer(issuer, playerIdentifiers, index + 1, containerNames, profileCounter));
+                .thenCompose(v -> migrateNextPlayer(issuer, fileNames, index + 1, profileCounter));
     }
 
-    private CompletableFuture<Void> run(
-            MVCommandIssuer issuer,
-            GlobalProfile profile,
-            Map<ContainerType, List<String>> containerNames,
-            AtomicLong profileCounter
-    ) {
+    private CompletableFuture<Void> run(GlobalProfile profile, AtomicLong profileCounter) {
         String playerName = profile.getLastKnownName();
         if (playerName == null || playerName.isEmpty()) {
             playerName = profile.getPlayerUUID().toString();
         }
-
-        CompletableFuture<Void> future = CompletableFuture.completedFuture(null);
-        for (ContainerType containerType : ContainerType.values()) {
-            List<String> dataNames = containerNames.get(containerType);
-            for (String dataName : dataNames) {
-                for (ProfileType profileType : ProfileTypes.getTypes()) {
-                    ProfileKey profileKey = ProfileKey.of(
-                            containerType,
-                            dataName,
-                            profileType,
-                            profile.getPlayerUUID(),
-                            playerName
-                    );
-                    future = future.thenCompose(v -> profileDataSource.getPlayerProfile(profileKey)
-                            .thenCompose(playerProfile -> {
-                                if (playerProfile.getData().isEmpty()) {
-                                    return CompletableFuture.completedFuture(null);
-                                }
-                                profileCounter.incrementAndGet();
-                                return profileDataSource.updatePlayerProfile(playerProfile);
-                            })
-                            .exceptionally(throwable -> {
-                                issuer.sendMessage(String.format("Error migrating profile %s %s/%s for player %s: %s",
-                                        containerType, dataName, profileType, profile.getPlayerUUID(), throwable.getMessage()));
-                                return null;
-                            })
-                    );
-                }
-            }
-        }
-        return future;
+        String finalPlayerName = playerName;
+
+        return CompletableFuture.allOf(Arrays.stream(ContainerType.values())
+                .flatMap(containerType -> profileDataSource.listContainerDataNames(containerType).stream()
+                        .flatMap(dataName -> ProfileTypes.getTypes().stream()
+                                .map(profileType -> profileDataSource.getPlayerProfile(ProfileKey.of(
+                                        containerType,
+                                        dataName,
+                                        profileType,
+                                        profile.getPlayerUUID(),
+                                        finalPlayerName
+                                )).thenCompose(playerProfile -> {
+                                    if (playerProfile.getData().isEmpty()) {
+                                        return CompletableFuture.completedFuture(null);
+                                    }
+                                    profileCounter.incrementAndGet();
+                                    return profileDataSource.updatePlayerProfile(playerProfile);
+                                }))))
+                .toArray(CompletableFuture[]::new));
     }
 }

src/main/java/org/mvplugins/multiverse/inventories/profile/FlatFileProfileDataSource.java

@@ -57,7 +57,7 @@ final class FlatFileProfileDataSource implements ProfileDataSource {
 
     private FileConfiguration loadFileToJsonConfiguration(File file) {
         JsonConfiguration jsonConfiguration = new JsonConfiguration();
-        jsonConfiguration.options().continueOnSerializationError(true);
+        jsonConfiguration.options().continueOnSerializationError(false);
         Try.run(() -> jsonConfiguration.load(file)).getOrElseThrow(e -> {
             Logging.severe("Could not load file %s : %s", file, e.getMessage());
             e.printStackTrace();