BukkitServerConfigProvider improvements (#159)

1 files changed, 87 insertions, 16 deletions

diff --git a/spark-bukkit/src/main/java/me/lucko/spark/bukkit/BukkitServerConfigProvider.java b/spark-bukkit/src/main/java/me/lucko/spark/bukkit/BukkitServerConfigProvider.java
index b1d2a60..5fdd178 100644
--- a/spark-bukkit/src/main/java/me/lucko/spark/bukkit/BukkitServerConfigProvider.java
+++ b/spark-bukkit/src/main/java/me/lucko/spark/bukkit/BukkitServerConfigProvider.java
@@ -20,8 +20,8 @@
 
 package me.lucko.spark.bukkit;
 
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonElement;
@@ -32,31 +32,31 @@ import me.lucko.spark.common.platform.serverconfig.AbstractServerConfigProvider;
 import org.bukkit.configuration.MemorySection;
 import org.bukkit.configuration.file.YamlConfiguration;
 
+import co.aikar.timings.TimingsManager;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 
 public class BukkitServerConfigProvider extends AbstractServerConfigProvider<BukkitServerConfigProvider.FileType> {
     private static final Gson GSON = new GsonBuilder()
             .registerTypeAdapter(MemorySection.class, (JsonSerializer<MemorySection>) (obj, type, ctx) -> ctx.serialize(obj.getValues(false)))
             .create();
 
-    private static final Map<String, FileType> FILES = ImmutableMap.of(
-            "bukkit.yml", FileType.YAML,
-            "spigot.yml", FileType.YAML,
-            "paper.yml", FileType.YAML
-    );
-
-    // todo: make configurable?
-    private static final List<String> HIDDEN_PATHS = ImmutableList.of(
-            "database",
-            "settings.bungeecord-addresses",
-            "settings.velocity-support.secret"
-    );
+    /** A map of provided files and their type */
+    private static final Map<String, FileType> FILES;
+    /** A collection of paths to be excluded from the files */
+    private static final Collection<String> HIDDEN_PATHS;
 
     public BukkitServerConfigProvider() {
         super(FILES, HIDDEN_PATHS);
@@ -64,15 +64,86 @@ public class BukkitServerConfigProvider extends AbstractServerConfigProvider<Buk
 
     @Override
     protected JsonElement load(String path, FileType type) throws IOException {
-        try (BufferedReader reader = Files.newBufferedReader(Paths.get(path), StandardCharsets.UTF_8)) {
-            YamlConfiguration config = YamlConfiguration.loadConfiguration(reader);
-            Map<String, Object> values = config.getValues(false);
+        Path filePath = Paths.get(path);
+        if (!Files.exists(filePath)) {
+            return null;
+        }
+
+        try (BufferedReader reader = Files.newBufferedReader(filePath, StandardCharsets.UTF_8)) {
+            Map<String, Object> values;
+
+            if (type == FileType.PROPERTIES) {
+                Properties properties = new Properties();
+                properties.load(reader);
+
+                values = new HashMap<>();
+                properties.forEach((k, v) -> {
+                    String key = k.toString();
+                    String value = v.toString();
+
+                    if ("true".equals(value) || "false".equals(value)) {
+                        values.put(key, Boolean.parseBoolean(value));
+                    } else if (value.matches("\\d+")) {
+                        values.put(key, Integer.parseInt(value));
+                    } else {
+                        values.put(key, value);
+                    }
+                });
+            } else if (type == FileType.YAML) {
+                YamlConfiguration config = YamlConfiguration.loadConfiguration(reader);
+                values = config.getValues(false);
+            } else {
+                throw new IllegalArgumentException("Unknown file type: " + type);
+            }
+
             return GSON.toJsonTree(values);
         }
     }
 
     enum FileType {
+        PROPERTIES,
         YAML
     }
 
+    static {
+        ImmutableMap.Builder<String, FileType> files = ImmutableMap.<String, FileType>builder()
+                .put("server.properties", FileType.PROPERTIES)
+                .put("bukkit.yml", FileType.YAML)
+                .put("spigot.yml", FileType.YAML)
+                .put("paper.yml", FileType.YAML)
+                .put("purpur.yml", FileType.YAML);
+
+        for (String config : getSystemPropertyList("spark.serverconfigs.extra")) {
+            files.put(config, FileType.YAML);
+        }
+
+        ImmutableSet.Builder<String> hiddenPaths = ImmutableSet.<String>builder()
+                .add("database")
+                .add("settings.bungeecord-addresses")
+                .add("settings.velocity-support.secret")
+                .add("server-ip")
+                .add("motd")
+                .add("resource-pack")
+                .addAll(getTimingsHiddenConfigs())
+                .addAll(getSystemPropertyList("spark.serverconfigs.hiddenpaths"));
+
+        FILES = files.build();
+        HIDDEN_PATHS = hiddenPaths.build();
+    }
+
+    private static List<String> getSystemPropertyList(String property) {
+        String value = System.getProperty(property);
+        return value == null
+                ? Collections.emptyList()
+                : Arrays.asList(value.split(","));
+    }
+
+    private static List<String> getTimingsHiddenConfigs() {
+        try {
+            return TimingsManager.hiddenConfigs;
+        } catch (NoClassDefFoundError e) {
+            return Collections.emptyList();
+        }
+    }
+
 }