Merge pull request #106 from UnknownCityMC/version/0.8.0

Version/0.8.0

Author: TheZexquex

.gitignore

@@ -116,3 +116,4 @@ run/
 
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 !gradle-wrapper.jar
+.gradle-home/

README.md

@@ -0,0 +1,22 @@
+# AstraLib
+
+AstraLib is a library for the faster development of Minecraft Paper and Velocity plugins.
+The name originates from a combination of the name Astralia (a Minecraft RPG server that never came to life) and the word library.
+Now it is used for serveral plugins for the german Minecraft CityBuild and Skyblocm server UnknownCity.de (whose development is currently paused)
+and some personal projects of TheZexquex.
+
+## Usage
+![Dynamic XML Badge](https://img.shields.io/badge/dynamic/xml?url=https%3A%2F%2Frepo.unknowncity.de%2Fsnapshots%2Fde%2Funknowncity%2Fastralib%2Fastralib-common%2Fmaven-metadata.xml&query=%2Fmetadata%2Fversioning%2Flatest&label=latest)
+
+Repository:
+```kts
+maven {
+    name = "unknowncitySnapshots"
+    url = uri("https://repo.unknowncity.de/snapshots")
+}
+```
+Dependency:
+AstraLib is available for the platforms `paper` and `velocity`
+```kts
+implementation("de.unknowncity.astralib:astralib-{{PLATFORM}}:{{VERSION}}")
+```

astralib-common/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
-    `maven-publish`
     id("java")
+    id("astralib-publishing")
 }
 
 val shadeBasePath = "${group}.${rootProject.name.lowercase()}."
@@ -27,8 +27,9 @@ dependencies {
     compileOnly(libs.adventure.text.minimessage)
     compileOnly(libs.adventure.api)
 
-    testImplementation(platform("org.junit:junit-bom:6.0.1"))
+    testImplementation(platform("org.junit:junit-bom:6.1.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 
     testCompileOnly(libs.jackson.yaml)
 }
@@ -49,30 +50,3 @@ tasks {
         useJUnitPlatform()
     }
 }
-
-publishing {
-    repositories {
-        maven {
-            name = "UnknownCity"
-            url = if(rootProject.version.toString().endsWith("-SNAPSHOT")) {
-                uri("https://repo.unknowncity.de/snapshots")
-            } else {
-                uri("https://repo.unknowncity.de/releases")
-            }
-
-            credentials {
-                username = System.getenv("MVN_REPO_USERNAME")
-                password = System.getenv("MVN_REPO_PASSWORD")
-            }
-        }
-    }
-
-    publications {
-        register<MavenPublication>("maven") {
-            from(components["java"])
-            group = rootProject.group
-            artifactId = project.name
-            version = rootProject.version.toString()
-        }
-    }
-}

astralib-common/src/main/java/de/unknowncity/astralib/common/command/ReloadCommand.java

@@ -0,0 +1,52 @@
+package de.unknowncity.astralib.common.command;
+
+import de.unknowncity.astralib.common.message.AbstractMessenger;
+import de.unknowncity.astralib.common.platform.AstraLib;
+import de.unknowncity.astralib.common.plugin.ReloadManager;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import org.incendo.cloud.CommandManager;
+import org.incendo.cloud.parser.standard.StringParser;
+import org.incendo.cloud.suggestion.SuggestionProvider;
+import org.spongepowered.configurate.NodePath;
+
+import java.util.logging.Level;
+
+/**
+ * The /astralib reload [plugin] command. Reloads any plugin registered
+ * in the {@link ReloadManager}. Platform independent, registered by the
+ * AstraLib platform plugins on their own command manager.
+ */
+public final class ReloadCommand {
+
+    private ReloadCommand() {
+
+    }
+
+    public static <C extends Audience> void register(CommandManager<C> commandManager, AbstractMessenger<?> messenger) {
+        commandManager.command(commandManager.commandBuilder("astralib")
+                .literal("reload")
+                .permission("astralib.command.reload")
+                .required("plugin", StringParser.stringParser(),
+                        SuggestionProvider.blockingStrings((context, input) -> ReloadManager.registeredPluginNames()))
+                .handler(context -> {
+                    String pluginName = context.get("plugin");
+                    var sender = context.sender();
+                    var pluginPlaceholder = Placeholder.parsed("plugin", pluginName);
+
+                    if (!ReloadManager.isRegistered(pluginName)) {
+                        messenger.sendMessage(sender, NodePath.path("command", "reload", "unknown-plugin"), pluginPlaceholder);
+                        return;
+                    }
+
+                    try {
+                        ReloadManager.reload(pluginName);
+                        messenger.sendMessage(sender, NodePath.path("command", "reload", "success"), pluginPlaceholder);
+                    } catch (Exception e) {
+                        AstraLib.getPlatform().getLogger().log(Level.SEVERE, "Failed to reload plugin " + pluginName, e);
+                        messenger.sendMessage(sender, NodePath.path("command", "reload", "error"), pluginPlaceholder);
+                    }
+                })
+        );
+    }
+}

astralib-common/src/main/java/de/unknowncity/astralib/common/command/SimpleCloudCaptionRegistry.java

@@ -1,11 +1,47 @@
 package de.unknowncity.astralib.common.command;
 
-import de.unknowncity.astralib.common.message.Messenger;
+import de.unknowncity.astralib.common.message.AbstractMessenger;
+import net.kyori.adventure.audience.Audience;
 import org.incendo.cloud.CommandManager;
+import org.incendo.cloud.caption.Caption;
+import org.incendo.cloud.caption.CaptionProvider;
+import org.incendo.cloud.caption.StandardCaptionKeys;
+import org.spongepowered.configurate.NodePath;
 
-public class SimpleCloudCaptionRegistry{
+import java.util.Map;
+import java.util.function.Function;
 
-    public static <C, P> void registerDefaultCaptions(CommandManager<C> commandManager, Messenger<P> messenger) {
+public final class SimpleCloudCaptionRegistry {
+    private static final Map<Caption, String> ARGUMENT_PARSE_CAPTIONS = Map.of(
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_BOOLEAN, "boolean",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_CHAR, "char",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_COLOR, "color",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_DURATION, "duration",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_ENUM, "enum",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_NUMBER, "number",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_REGEX, "regex",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_STRING, "string",
+            StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_UUID, "uuid"
+    );
 
+    private SimpleCloudCaptionRegistry() {
+    }
+
+    /**
+     * Registers messenger backed caption providers for clouds standard
+     * argument-parse failure captions. Lang path: exception.argument-parse.[type]
+     * @param commandManager the command manager whose caption registry gets populated
+     * @param messenger the messenger resolving the lang strings
+     * @param playerMapper maps a command sender to a platform player, returning null for non-players
+     */
+    public static <C, P extends Audience> void registerDefaultCaptions(
+            CommandManager<C> commandManager,
+            AbstractMessenger<P> messenger,
+            Function<C, P> playerMapper
+    ) {
+        ARGUMENT_PARSE_CAPTIONS.forEach((caption, type) -> commandManager.captionRegistry().registerProvider(
+                CaptionProvider.forCaption(caption, sender -> messenger.getNullableString(
+                        playerMapper.apply(sender), NodePath.path("exception", "argument-parse", type)))
+        ));
     }
 }

astralib-common/src/main/java/de/unknowncity/astralib/common/configuration/YamlAstraConfiguration.java

@@ -14,6 +14,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.Optional;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -46,6 +47,7 @@ public static <T extends YamlAstraConfiguration> Optional<T> loadFromFile(Class<
             return Optional.of(config);
         } catch (IOException e) {
             Logger.getLogger("Configuration").log(Level.SEVERE, "Error while reading configuration file", e);
+            backupBrokenConfig(configPath);
             return Optional.empty();
         }
     }
@@ -69,10 +71,26 @@ public static <T extends YamlAstraConfiguration> Optional<T> loadFromFile(Class<
             return Optional.of(objectMapper.readValue(configPath.toFile(), configurationClass));
         } catch (IOException e) {
             Logger.getLogger("Configuration").log(Level.SEVERE, "Error while reading configuration file", e);
+            backupBrokenConfig(configPath);
             return Optional.empty();
         }
     }
 
+    /**
+     * Copies an unreadable configuration file to a ".broken" sibling so that user edits
+     * are not lost when the configuration is rewritten with defaults afterwards
+     * @param configPath the path of the unreadable configuration file
+     */
+    private static void backupBrokenConfig(Path configPath) {
+        var backupPath = configPath.resolveSibling(configPath.getFileName() + ".broken");
+        try {
+            Files.copy(configPath, backupPath, StandardCopyOption.REPLACE_EXISTING);
+            Logger.getLogger("Configuration").log(Level.WARNING, "Backed up broken configuration to " + backupPath);
+        } catch (IOException e) {
+            Logger.getLogger("Configuration").log(Level.SEVERE, "Failed to back up broken configuration file", e);
+        }
+    }
+
 
     public void save() {
         var configPath = pluginDataPath == null ? targetFile() : pluginDataPath.resolve(targetFile());

astralib-common/src/main/java/de/unknowncity/astralib/common/configuration/setting/defaults/ModernRedisSetting.java

@@ -12,7 +12,7 @@ public final class RedisSetting {
     @JsonProperty
     private final String password = null;
     @JsonProperty
-    private final boolean ssl = true;
+    private final boolean ssl = false;
 
     public RedisSetting() {
 

astralib-common/src/main/java/de/unknowncity/astralib/common/configuration/setting/defaults/RedisSetting.java

@@ -0,0 +1,21 @@
+package de.unknowncity.astralib.common.database.dao;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Shared pool for blocking JDBC calls so daos don't occupy the common fork-join pool
+ */
+public final class DaoExecutor {
+    private static final AtomicInteger THREAD_COUNTER = new AtomicInteger(1);
+    public static final ExecutorService EXECUTOR = Executors.newFixedThreadPool(2, runnable -> {
+        var thread = new Thread(runnable, "astralib-dao-" + THREAD_COUNTER.getAndIncrement());
+        thread.setDaemon(true);
+        return thread;
+    });
+
+    private DaoExecutor() {
+
+    }
+}

astralib-common/src/main/java/de/unknowncity/astralib/common/database/dao/DaoExecutor.java

@@ -1,4 +1,4 @@
-package de.unknowncity.astralib.paper.plugin.database.dao.language;
+package de.unknowncity.astralib.common.database.dao.language;
 
 import de.unknowncity.astralib.common.message.lang.Language;