Migrate config system to YAML via Jackson

Config is now read via directly instantiating it. There is now also the possibility to specify the SQL type for the underlying database implementation. Currently supported is PostgreSQL, MariaDB, MySQL and SQLite.
Version catalogue was moved into its own file.

Author: JvstvsHD

api/src/main/java/de/jvstvshd/velocitypunishment/api/message/MessageProvider.java

@@ -50,4 +50,13 @@ public interface MessageProvider {
 
     @NotNull
     Component provide(String key, CommandSource source, boolean withPrefix, Component... args);
+
+    @NotNull
+    default Component prefixed(CommandSource source, Component... args) {
+        var comp = prefix(source);
+        for (Component arg : args) {
+            comp = comp.append(arg);
+        }
+        return comp;
+    }
 }

gradle/libs.versions.toml

@@ -0,0 +1,40 @@
+# Generate from settings.gradle.kts
+
+[versions]
+velocity-api = "3.3.0-SNAPSHOT"
+luckperms-api = "5.4"
+jackson-databind = "2.13.4"
+jackson-datatype-jsr310 = "2.13.4"
+jackson-yaml = "2.13.4"
+postgresql = "42.5.0"
+hikari = "5.0.1"
+sadu = "1.4.1"
+junit = "5.9.1"
+paper-api = "1.19.2-R0.1-SNAPSHOT"
+brigadier = "1.0.17"
+mariadb = "3.4.0"
+sqlite = "3.45.3.0"
+mysql = "8.4.0"
+
+[libraries]
+
+velocity-api = { group = "com.velocitypowered", name = "velocity-api", version.ref = "velocity-api" }
+luckperms-api = { group = "net.luckperms", name = "api", version.ref = "luckperms-api" }
+jackson-databind = { group = "com.fasterxml.jackson.core", name = "jackson-databind", version.ref = "jackson-databind" }
+jackson-yaml = { group = "com.fasterxml.jackson.dataformat", name = "jackson-dataformat-yaml", version.ref = "jackson-yaml" }
+jackson-datatype-jsr310 = { group = "com.fasterxml.jackson.datatype", name = "jackson-datatype-jsr310", version.ref = "jackson-datatype-jsr310" }
+postgresql = { group = "org.postgresql", name = "postgresql", version.ref = "postgresql" }
+hikari = { group = "com.zaxxer", name = "HikariCP", version.ref = "hikari" }
+sadu = { group = "de.chojo.sadu", name = "sadu", version.ref = "sadu" }
+junit-jupiter-api = { group = "org.junit.jupiter", name = "junit-jupiter-api", version.ref = "junit" }
+junit-jupiter-engine = { group = "org.junit.jupiter", name = "junit-jupiter-engine", version.ref = "junit" }
+paper-api = { group = "io.papermc.paper", name = "paper-api", version.ref = "paper-api" }
+brigadier = { group = "com.mojang", name = "brigadier", version.ref = "brigadier" }
+mariadb = { group = "org.mariadb.jdbc", name = "mariadb-java-client", version.ref = "mariadb" }
+sqlite = { group = "org.xerial", name = "sqlite-jdbc", version.ref = "sqlite" }
+mysql = { group = "com.mysql", name = "mysql-connector-j", version.ref = "mysql" }
+
+[bundles]
+
+database = ["postgresql", "hikari", "sadu", "mariadb", "sqlite", "mysql"]
+jackson = ["jackson-databind", "jackson-yaml", "jackson-datatype-jsr310"]

plugin/build.gradle.kts

@@ -1,7 +1,7 @@
 plugins {
     java
     id("com.github.johnrengelman.shadow") version "7.1.2"
-    id("xyz.jpenilla.run-velocity") version "2.1.0"
+    id("xyz.jpenilla.run-velocity") version "2.3.0"
     `java-library`
 }
 
@@ -37,7 +37,7 @@ tasks {
         // Configure the Velocity version for our task.
         // This is the only required configuration besides applying the plugin.
         // Your plugin's jar (or shadowJar if present) will be used automatically.
-        velocityVersion("3.2.0-SNAPSHOT")
+        velocityVersion("3.3.0-SNAPSHOT")
     }
 
     val copyServerJar = task<Copy>("copyServerJar") {

plugin/src/main/java/de/jvstvshd/velocitypunishment/VelocityPunishmentPlugin.java

@@ -35,8 +35,12 @@
 import com.velocitypowered.api.proxy.messages.ChannelIdentifier;
 import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
 import com.zaxxer.hikari.HikariDataSource;
+import de.chojo.sadu.databases.Database;
 import de.chojo.sadu.databases.PostgreSql;
+import de.chojo.sadu.databases.SqLite;
 import de.chojo.sadu.datasource.DataSourceCreator;
+import de.chojo.sadu.datasource.stage.ConfigurationStage;
+import de.chojo.sadu.jdbc.RemoteJdbcConfig;
 import de.chojo.sadu.updater.SqlUpdater;
 import de.chojo.sadu.wrapper.QueryBuilderConfig;
 import de.jvstvshd.velocitypunishment.api.VelocityPunishment;
@@ -56,7 +60,8 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -68,12 +73,14 @@ public class VelocityPunishmentPlugin implements VelocityPunishment {
     private final Logger logger;
     private final ConfigurationManager configurationManager;
     private final ExecutorService service = Executors.newCachedThreadPool();
+    private final Path dataDirectory;
     public static final ChannelIdentifier MUTE_DATA_CHANNEL_IDENTIFIER = MinecraftChannelIdentifier.from(MuteData.MUTE_DATA_CHANNEL_IDENTIFIER);
     private PunishmentManager punishmentManager;
     private HikariDataSource dataSource;
     private PlayerResolver playerResolver;
     private MessageProvider messageProvider;
 
+
     private static final String MUTES_DISABLED_STRING = """
             Since 1.19.1, cancelling chat messages on proxy is not possible anymore. Therefore, we have to listen to the chat event on the actual game server. This means
             that there has to be a spigot/paper extension to this plugin which is not yet available unless there's a possibility. Therefore all mute related features won't work at the moment.
@@ -92,14 +99,15 @@ public class VelocityPunishmentPlugin implements VelocityPunishment {
     public VelocityPunishmentPlugin(ProxyServer server, Logger logger, @DataDirectory Path dataDirectory) {
         this.server = server;
         this.logger = logger;
-        this.configurationManager = new ConfigurationManager(Paths.get(dataDirectory.toAbsolutePath().toString(), "config.json"));
+        this.configurationManager = new ConfigurationManager(dataDirectory.resolve("config.yml"));
         this.playerResolver = new DefaultPlayerResolver(server);
         this.communicator = new MessagingChannelCommunicator(server, logger);
+        this.dataDirectory = dataDirectory;
     }
 
     @Subscribe
     public void onProxyInitialization(ProxyInitializeEvent event) {
-        Thread.setDefaultUncaughtExceptionHandler((t, e) -> logger.error("An error occurred in thread " + t.getName(), e));
+        Thread.setDefaultUncaughtExceptionHandler((t, e) -> logger.error("An error occurred in thread {}", t.getName(), e));
         try {
             configurationManager.load();
             if (configurationManager.getConfiguration().isWhitelistActivated()) {
@@ -114,9 +122,9 @@ public void onProxyInitialization(ProxyInitializeEvent event) {
         punishmentManager = new DefaultPunishmentManager(server, dataSource, this);
         try {
             updateDatabase();
-            //initDataSource();
+            initDataSource();
         } catch (SQLException | IOException e) {
-            logger.error("Could not create table velocity_punishment in database " + dataSource.getDataSourceProperties().get("dataSource.databaseName"), e);
+            logger.error("Could not create table velocity_punishment in database {}", dataSource.getDataSourceProperties().get("dataSource.databaseName"), e);
         }
         setup(server.getCommandManager(), server.getEventManager());
         logger.info("Velocity Punishment Plugin v1.0.0 has been loaded");
@@ -139,28 +147,59 @@ private void setup(CommandManager commandManager, EventManager eventManager) {
         commandManager.register(WhitelistCommand.whitelistCommand(this));
     }
 
+    @SuppressWarnings({"unchecked", "UnstableApiUsage"})
     private HikariDataSource createDataSource() {
         var dbData = configurationManager.getConfiguration().getDataBaseData();
-        //TODO add config option for sql type
-        return DataSourceCreator.create(PostgreSql.get())
-                .configure(jdbcConfig -> jdbcConfig.host(dbData.getHost())
-                        .port(dbData.getPort())
-                        .database(dbData.getDatabase())
-                        .user(dbData.getUsername())
-                        .password(dbData.getPassword())
-                        .applicationName("Velocity Punishment Plugin"))
-                .create().withMaximumPoolSize(dbData.getMaxPoolSize())
+        ConfigurationStage stage = switch (dbData.sqlType().name().toLowerCase()) {
+            case "sqlite" -> DataSourceCreator.create(SqLite.get())
+                    .configure(sqLiteJdbc -> sqLiteJdbc.path(dataDirectory.resolve("punishment.db")))
+                    .create();
+            case "postgresql" ->
+                    DataSourceCreator.create(PostgreSql.get()).configure(jdbcConfig -> jdbcConfig.host(dbData.getHost())
+
+                                    .port(dbData.getPort())
+                                    .database(dbData.getDatabase())
+                                    .user(dbData.getUsername())
+                                    .password(dbData.getPassword())
+                            )
+                            .create();
+
+            default ->
+                    DataSourceCreator.create((Database<RemoteJdbcConfig<?>, ?>) dbData.sqlType()).configure(jdbcConfig -> jdbcConfig.host(dbData.getHost())
+                                    .port(dbData.getPort())
+                                    .database(dbData.getDatabase())
+                                    .user(dbData.getUsername())
+                                    .password(dbData.getPassword()))
+                            .create();
+        };
+        return stage.withMaximumPoolSize(dbData.getMaxPoolSize())
                 .withMinimumIdle(dbData.getMinIdle())
                 .withPoolName("velocity-punishment-hikari")
+                .forSchema(dbData.getPostgresSchema())
                 .build();
     }
 
+    @SuppressWarnings("UnstableApiUsage")
     private void updateDatabase() throws IOException, SQLException {
-        //TODO config option for sql type
-        SqlUpdater.builder(dataSource, PostgreSql.get())
-                .setSchemas("punishment")
-                .execute();
+        if (configurationManager.getConfiguration().getDataBaseData().sqlType().name().equalsIgnoreCase("postgresql")) {
+            SqlUpdater.builder(dataSource, PostgreSql.get())
+                    .setSchemas(configurationManager.getConfiguration().getDataBaseData().getPostgresSchema())
+                    .execute();
+        } else {
+            logger.warn("Database type is not (yet) supported for automatic updates. Please update the database manually.");
+        }
+    }
 
+    private void initDataSource() throws SQLException {
+        try (Connection connection = dataSource.getConnection(); PreparedStatement statement =
+                connection.prepareStatement("CREATE TABLE IF NOT EXISTS velocity_punishment (uuid  VARCHAR (36), name VARCHAR (16), type VARCHAR (1000), expiration DATETIME (6), " +
+                        "reason VARCHAR (1000), punishment_id VARCHAR (36))")) {
+            statement.execute();
+        }
+        try (Connection connection = dataSource.getConnection(); PreparedStatement statement =
+                connection.prepareStatement("CREATE TABLE IF NOT EXISTS velocity_punishment_whitelist (uuid VARCHAR (36))")) {
+            statement.execute();
+        }
     }
 
     @Override
@@ -219,4 +258,8 @@ public Logger getLogger() {
     public boolean whitelistActive() {
         return configurationManager.getConfiguration().isWhitelistActivated();
     }
+
+    public ConfigurationManager getConfig() {
+        return configurationManager;
+    }
 }

plugin/src/main/java/de/jvstvshd/velocitypunishment/commands/WhitelistCommand.java

@@ -38,56 +38,83 @@
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 
+import java.io.IOException;
 import java.util.List;
+import java.util.Locale;
 
 public class WhitelistCommand {
 
-    public static final List<String> options = ImmutableList.of("add", "remove");
+    public static final List<String> options = ImmutableList.of("add", "remove", "on", "off");
 
 
     public static BrigadierCommand whitelistCommand(VelocityPunishmentPlugin plugin) {
         var node = Util.permissibleCommand("whitelist", "velocitypunishment.command.whitelist")
-                .then(Util.playerArgument(plugin.getServer()).executes(context -> execute(context, plugin))
-                        .then(RequiredArgumentBuilder.<CommandSource, String>argument("option", StringArgumentType.word()).executes(context -> execute(context, plugin))
-                                .suggests((context, builder) -> {
-                                    for (String option : options) {
-                                        builder.suggest(option);
-                                    }
-                                    return builder.buildFuture();
-                                })));
+                .then(RequiredArgumentBuilder.<CommandSource, String>argument("option", StringArgumentType.word())
+                        .executes(context -> execute(context, plugin))
+                        .suggests((context, builder) -> {
+                            for (String option : options) {
+                                if (context.getArguments().containsKey("option") && !context.getArgument("option", String.class).isEmpty() &&
+                                        !option.startsWith(context.getArgument("option", String.class).toLowerCase(Locale.ROOT)))
+                                    continue;
+                                builder.suggest(option);
+                            }
+                            return builder.buildFuture();
+                        })
+                        .then(Util.playerArgument(plugin.getServer()).executes(context -> execute(context, plugin))));
         return new BrigadierCommand(node);
     }
 
     private static int execute(CommandContext<CommandSource> context, VelocityPunishmentPlugin plugin) {
         var source = context.getSource();
-        if (!plugin.whitelistActive()) {
-            source.sendMessage(Component.text("Whitelist is not active. You may activate it by setting 'whitelistActivated' in 'plugins/velocity-punishment/config.json' to true.", NamedTextColor.RED));
-            return Command.SINGLE_SUCCESS;
+        String player;
+        if (context.getArguments().containsKey("player")) {
+            player = context.getArgument("player", String.class);
+        } else {
+            player = null;
         }
-        var player = context.getArgument("player", String.class);
         if (context.getArguments().containsKey("option")) {
             var option = context.getArgument("option", String.class).toLowerCase();
             switch (option) {
-                case "add", "remove" ->
-                        plugin.getPlayerResolver().getOrQueryPlayerUuid(player, plugin.getService()).whenCompleteAsync((uuid, throwable) -> {
-                            if (Util.sendErrorMessageIfErrorOccurred(context, uuid, throwable, plugin)) return;
-                            var builder = QueryBuilder.builder(plugin.getDataSource())
-                                    .configure(QueryBuilderConfig.defaultConfig())
-                                    .query(option.equalsIgnoreCase("remove") ? "DELETE FROM velocity_punishment_whitelist WHERE uuid = ?;" :
-                                            "INSERT INTO velocity_punishment_whitelist (uuid) VALUES (?);")
-                                    .parameter(paramBuilder -> paramBuilder.setUuidAsString(uuid));
-                            if (option.equalsIgnoreCase("remove")) {
-                                builder.delete().send();
-                                plugin.getServer().getPlayer(uuid).ifPresent(pl -> pl.disconnect(Component.text("You have been blacklisted.").color(NamedTextColor.DARK_RED)));
-                            } else {
-                                builder.insert().send();
-                            }
-                        }, plugin.getService());
+                case "add", "remove" -> {
+                    if (player == null) {
+                        source.sendMessage(plugin.getMessageProvider().provide("command.whitelist.usage", source, true));
+                        return Command.SINGLE_SUCCESS;
+                    }
+                    plugin.getPlayerResolver().getOrQueryPlayerUuid(player, plugin.getService()).whenCompleteAsync((uuid, throwable) -> {
+                        if (Util.sendErrorMessageIfErrorOccurred(context, uuid, throwable, plugin)) return;
+                        var builder = QueryBuilder.builder(plugin.getDataSource())
+                                .configure(QueryBuilderConfig.defaultConfig())
+                                .query(option.equalsIgnoreCase("remove") ? "DELETE FROM velocity_punishment_whitelist WHERE uuid = ?;" :
+                                        "INSERT INTO velocity_punishment_whitelist (uuid) VALUES (?);")
+                                .parameter(paramBuilder -> paramBuilder.setUuidAsString(uuid));
+                        if (option.equalsIgnoreCase("remove")) {
+                            builder.delete().send();
+                            plugin.getServer().getPlayer(uuid).ifPresent(pl -> pl.disconnect(Component.text("You have been blacklisted.").color(NamedTextColor.DARK_RED)));
+                        } else {
+                            builder.insert().send();
+                        }
+                    }, plugin.getService());
+                }
+                case "on", "off" -> {
+                    var config = plugin.getConfig();
+                    config.getConfiguration().setWhitelistActivated(option.equals("on"));
+                    try {
+                        config.save();
+                        source.sendMessage(plugin.getMessageProvider().prefixed(source, Component.text("The whitelist is now " + option).color(NamedTextColor.GRAY)));
+                    } catch (IOException e) {
+                        source.sendMessage(plugin.getMessageProvider().internalError(source, true));
+                        plugin.getLogger().error("Could not save the configuration.", e);
+                    }
+                }
                 default ->
                         source.sendMessage(plugin.getMessageProvider().provide("command.whitelist.usage", source, true));
             }
             return Command.SINGLE_SUCCESS;
         }
+        if (player == null) {
+            source.sendMessage(plugin.getMessageProvider().provide("command.whitelist.usage", source, true));
+            return Command.SINGLE_SUCCESS;
+        }
         plugin.getPlayerResolver().getOrQueryPlayerUuid(player, plugin.getService()).whenCompleteAsync((uuid, throwable) -> {
             if (Util.sendErrorMessageIfErrorOccurred(context, uuid, throwable, plugin)) return;
             QueryBuilder.builder(plugin.getDataSource(), Boolean.class)

plugin/src/main/java/de/jvstvshd/velocitypunishment/config/ConfigData.java

@@ -24,17 +24,36 @@
 
 package de.jvstvshd.velocitypunishment.config;
 
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
 import java.util.Locale;
 
-@SuppressWarnings({"FieldMayBeFinal", "FieldCanBeLocal"})
 public class ConfigData {
 
-    private DataBaseData dataBaseData = new DataBaseData();
-    private Locale forcedLanguage = null;
+    @JsonProperty("database")
+    @JsonAlias("dataBaseData")
+    private final DataBaseData dataBaseData;
+
+    @JsonProperty("forced-language")
+    @JsonAlias("forcedLanguage")
+    private final Locale forcedLanguage;
+
+    @JsonProperty("whitelist-activated")
+    @JsonAlias("whitelistActivated")
+    private boolean whitelistActivated;
+
+    public ConfigData(DataBaseData dataBaseData, Locale forcedLanguage, boolean whitelistActivated) {
+        this.dataBaseData = dataBaseData;
+        this.forcedLanguage = forcedLanguage;
+        this.whitelistActivated = whitelistActivated;
+    }
 
-    private boolean whitelistActivated = false;
+    public ConfigData() {
+        this(new DataBaseData(), Locale.ENGLISH, false);
+    }
 
-    public DataBaseData getDataBaseData() {
+    public final DataBaseData getDataBaseData() {
         return dataBaseData;
     }
 
@@ -45,4 +64,8 @@ public Locale getForcedLanguage() {
     public boolean isWhitelistActivated() {
         return whitelistActivated;
     }
+
+    public void setWhitelistActivated(boolean whitelistActivated) {
+        this.whitelistActivated = whitelistActivated;
+    }
 }