Load schematic cache async (#443)

* Load schematic cache async

* Prevent reloading cache while reload is running

* Bump version

Author: rainbowdashlabs

build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 }
 
 group = "de.eldoria"
-version = "2.7.9"
+version = "2.7.10"
 
 var publishModules = setOf(
     "schematicbrushreborn-api",

schematicbrushreborn-api/src/main/java/de/eldoria/schematicbrush/schematics/SchematicCache.java

@@ -11,6 +11,7 @@
 
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * A cache which provides schematics based on filters or other factors.
@@ -23,13 +24,17 @@ public interface SchematicCache {
 
     /**
      * Init method which will be executed when registered via {@link SchematicRegistry#register(Nameable, Object)}
+     *
+     * @return A future which completes when the cache is ready.
      */
-    void init();
+    CompletableFuture<Void> init();
 
     /**
-     * Reload all schematics of the cache.
+     * Reload the currently loaded schematics. This overrides the cache when the schematics are loaded.
+     *
+     * @return A future which completes when the reload is finished.
      */
-    void reload();
+    CompletableFuture<Void> reload();
 
     /**
      * Get a list of schematics which match a name or regex
@@ -84,6 +89,15 @@ public interface SchematicCache {
      */
     int directoryCount();
 
+    /**
+     * Returns whether the cache is ready to be used.
+     * A cache might not be ready to be used if it is still loading, for example.
+     * A cache that is not ready might, however, be used already and can return schematics.
+     *
+     * @return true if the cache is ready
+     */
+    boolean isReady();
+
     /**
      * Called when the plugin gets shutdown and the cache is unregistered.
      */

schematicbrushreborn-api/src/main/java/de/eldoria/schematicbrush/schematics/SchematicRegistry.java

@@ -9,6 +9,8 @@
 import de.eldoria.schematicbrush.brush.config.util.Nameable;
 import de.eldoria.schematicbrush.registry.Registry;
 
+import java.util.concurrent.CompletableFuture;
+
 /**
  * A registry to register, manage and retrieve a {@link SchematicCache}.
  */
@@ -30,7 +32,7 @@ default SchematicCache getCache(Nameable key) {
     /**
      * Reloads all registered caches.
      */
-    void reload();
+    CompletableFuture<Void> reload();
 
     /**
      * Returns the total amount of registered schematics

schematicbrushreborn-core/src/main/java/de/eldoria/schematicbrush/SchematicBrushRebornImpl.java

@@ -165,7 +165,7 @@ public void onPluginLoad() throws Throwable {
     }
 
     @Override
-    public void onPluginEnable() {
+    public void onPluginEnable(boolean reload) {
         var localizer = Localizer.builder(this, configuration.general().language())
                                  .setIncludedLocales(LANGUAGES)
                                  .build();
@@ -193,7 +193,7 @@ public void onPluginEnable() {
         var notifyListener = new NotifyListener(this, configuration);
         renderService = new RenderService(this, configuration);
 
-        reload();
+        if (reload) reload();
 
         MessageBlocker messageBlocker;
         if (ServerVersion.CURRENT_VERSION.isOlder(Version.of(1, 19))) {

schematicbrushreborn-core/src/main/java/de/eldoria/schematicbrush/commands/admin/ReloadCache.java

@@ -28,7 +28,8 @@ public ReloadCache(SchematicBrushRebornImpl plugin, SchematicRegistry cache) {
 
     @Override
     public void onCommand(@NotNull CommandSender sender, @NotNull String alias, @NotNull Arguments args) {
-        cache.reload();
-        messageSender().sendMessage(sender, "commands.admin.reloadCache.done");
+        messageSender().sendMessage(sender, "commands.admin.reloadCache.start");
+        cache.reload()
+             .thenRun(() -> messageSender().sendMessage(sender, "commands.admin.reloadCache.done"));
     }
 }

schematicbrushreborn-core/src/main/java/de/eldoria/schematicbrush/schematics/SchematicBrushCache.java

@@ -6,6 +6,7 @@
 
 package de.eldoria.schematicbrush.schematics;
 
+import de.eldoria.eldoutilities.messages.MessageSender;
 import de.eldoria.eldoutilities.utils.TextUtil;
 import de.eldoria.schematicbrush.SchematicBrushRebornImpl;
 import de.eldoria.schematicbrush.config.Configuration;
@@ -31,6 +32,8 @@
 import java.util.Queue;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
@@ -42,26 +45,46 @@ public class SchematicBrushCache implements SchematicCache {
     private static final Logger logger = SchematicBrushRebornImpl.logger();
     private final JavaPlugin plugin;
     private final Configuration configuration;
-    private final Map<String, Set<Schematic>> schematicsCache = new HashMap<>();
-    private final Map<UUID, Map<String, Set<Schematic>>> userCache = new HashMap<>();
+    private final Map<String, Set<Schematic>> schematicsCache = new ConcurrentHashMap<>();
+    private final Map<UUID, Map<String, Set<Schematic>>> userCache = new ConcurrentHashMap<>();
     private SchematicWatchService watchService;
+    private boolean ready;
+    private final MessageSender messageSender;
 
     public SchematicBrushCache(JavaPlugin plugin, Configuration configuration) {
         this.plugin = plugin;
         this.configuration = configuration;
+        this.messageSender = MessageSender.getPluginMessageSender(plugin);
     }
 
     @Override
-    public void init() {
-        reload();
+    public CompletableFuture<Void> init() {
         watchService = SchematicWatchService.of(plugin, configuration, this);
+        return reload();
     }
 
-    /**
-     * Reload the current loaded schematics. This overrides the cache, when the schematics are loaded.
-     */
     @Override
-    public void reload() {
+    public CompletableFuture<Void> reload() {
+        return refreshAsync();
+    }
+
+    private void assertReady(Player player) {
+        if (!ready) {
+            messageSender.sendError(player, "error.cacheNotReady");
+        }
+    }
+
+    private CompletableFuture<Void> refreshAsync() {
+        return CompletableFuture.runAsync(this::refreshSync)
+                                .exceptionally(ex -> {
+                                    logger.log(Level.SEVERE, "Failed to reload schematics.", ex);
+                                    return null;
+                                });
+    }
+
+    private void refreshSync() {
+        ready = false;
+
         plugin.getLogger().log(Level.CONFIG, "Reloading schematics.");
 
         var root = plugin.getDataFolder().toPath().getParent().toString();
@@ -82,6 +105,7 @@ public void reload() {
             var load = source.isRelative() ? Paths.get(root, path) : Paths.get(path);
             loadSchematics(load, source);
         }
+        ready = true;
     }
 
     private void loadSchematics(Path schematicFolder, SchematicSource source) {
@@ -199,8 +223,8 @@ private void importSchematic(Path path, SchematicSource source) {
 
         if (playerUid != null) {
             userCache.computeIfAbsent(playerUid, key -> new HashMap<>())
-                    .computeIfAbsent(cleanKey, key -> new HashSet<>())
-                    .add(schematic);
+                     .computeIfAbsent(cleanKey, key -> new HashSet<>())
+                     .add(schematic);
         } else {
             schematicsCache.computeIfAbsent(cleanKey, key -> new HashSet<>()).add(schematic);
         }
@@ -261,6 +285,7 @@ private Set<Schematic> filterSchematics(Set<Schematic> schematics, String filter
      */
     @Override
     public Set<Schematic> getSchematicsByDirectory(Player player, String name, String filter) {
+        assertReady(player);
         // if folder name ends with a '*' perform a deep search and return every schematic in folder and sub folders.
         if (name.endsWith("*")) {
             var pureName = name.replace("*", "").toLowerCase();
@@ -346,6 +371,7 @@ private Pattern buildRegex(String name) throws PatternSyntaxException {
      */
     @Override
     public List<String> getMatchingDirectories(Player player, String dir, int count) {
+        assertReady(player);
         Set<String> matches = new HashSet<>();
         var separator = configuration.schematicConfig().pathSeparator().charAt(0);
         var deep = TextUtil.countChars(dir, separator);
@@ -386,6 +412,7 @@ private String trimPath(String input, char separator, int deep) {
      */
     @Override
     public List<String> getMatchingSchematics(Player player, String name, int count) {
+        assertReady(player);
         List<String> matches = new ArrayList<>();
         for (var entry : schematicsCache.entrySet()) {
             for (var schematic : entry.getValue()) {
@@ -420,6 +447,11 @@ public int directoryCount() {
         return schematicsCache.keySet().size();
     }
 
+    @Override
+    public boolean isReady() {
+        return ready;
+    }
+
     @Override
     public void shutdown() {
         watchService.shutdown();

schematicbrushreborn-core/src/main/java/de/eldoria/schematicbrush/schematics/SchematicRegistryImpl.java

@@ -11,9 +11,11 @@
 import de.eldoria.schematicbrush.registry.BaseRegistry;
 
 import java.util.HashSet;
+import java.util.concurrent.CompletableFuture;
 
 @SuppressWarnings("unused")
 public class SchematicRegistryImpl extends BaseRegistry<Nameable, SchematicCache> implements SchematicRegistry {
+    boolean reload = false;
 
 
     @Override
@@ -26,8 +28,10 @@ public void register(Nameable key, SchematicCache entry) {
      * Reloads all registered caches.
      */
     @Override
-    public void reload() {
-        registry().values().forEach(SchematicCache::reload);
+    public CompletableFuture<Void> reload() {
+        if (reload) {return CompletableFuture.completedFuture(null);}
+        var reloads = registry().values().stream().map(SchematicCache::reload).toArray(CompletableFuture[]::new);
+        return CompletableFuture.allOf(reloads).thenRun(() -> reload = true);
     }
 
     /**

schematicbrushreborn-core/src/main/resources/messages.properties

@@ -162,6 +162,7 @@ error.unknownModifierType=
 error.unknownPlayer=
 error.unknownPreset=
 error.unknownWorld=
+error.cacheNotReady=
 
 service.renderService.error.sizeExceeded=
 
@@ -184,3 +185,4 @@ words.schematics=
 words.selector=
 words.sets=
 words.weight=
+commands.admin.reloadCache.start=

schematicbrushreborn-core/src/main/resources/messages_de_DE.properties

@@ -182,3 +182,5 @@ words.weight=Gewichtung
 components.brush.information=Informationen über Brush
 components.preset.information=Informationen über Vorlage
 words.description=Beschreibung
+commands.admin.reloadCache.start=Lade Schematics neu. Das kann eine Weile dauern.
+error.cacheNotReady=Der Cache lädt derzeit. Ergebnisse sind eventuell unvollständig.

schematicbrushreborn-core/src/main/resources/messages_en_US.properties

@@ -190,3 +190,5 @@ components.brush.information=Information about brush
 components.preset.information=Information about preset
 
 words.description=Description
+commands.admin.reloadCache.start=Reloading schematics. This might take a while.
+error.cacheNotReady=The cache is currently loading. Results might be incomplete.