Load default args from default_args.properties

This allows us to inject default_args from the download server, e.g. to dynamically create nightly installers.

Author: LeafHacker

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- The ability to override CLI argument defaults from a properties file in the jar. This means the Donator Installer can be generated dynamically by the website.
+
 ## [0.8.3] - 2020-02-21
 
 ### Fixed

src/main/java/io/github/ImpactDevelopment/installer/Args.java

@@ -31,10 +31,14 @@
 import io.github.ImpactDevelopment.installer.setting.settings.*;
 import io.github.ImpactDevelopment.installer.target.InstallationModeOptions;
 
+import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Properties;
 
 public class Args {
 
@@ -74,6 +78,39 @@ public class Args {
     @Parameter(names = {"--version"}, description = "Output version information and exit\n", help = true, order = 1)
     public boolean showVersion = false;
 
+    public Args() {
+        // Lets look for a properties file and use it to override defaults
+        try {
+            getProperties("default_args.properties").forEach((o1, o2) -> {
+                String key, value;
+                try {
+                    key = (String) o1;
+                    value = (String) o2;
+                } catch (Throwable ignored) {
+                    System.err.println("WTF! unable to cast key or value to string: " + o1 + ", " + o2);
+                    return;
+                }
+
+                try {
+                    Field field = Args.class.getField(key);
+                    if (!field.isAnnotationPresent(Parameter.class)) {
+                        System.err.println("default_args.properties tried to override non-parameter field " + field.getName());
+                        return;
+                    }
+                    // Parse value to the correct type and set the field's value
+                    field.set(this, toType(field.getType(), value));
+                } catch (Throwable t) {
+                    System.err.println("Error setting default value: " + key + " = " + value);
+                    t.printStackTrace();
+                }
+            });
+        } catch (Throwable t) {
+            if (!(t instanceof FileNotFoundException)) {
+                t.printStackTrace();
+            }
+        }
+    }
+
     public void apply(InstallationConfig config) {
         if (mcPath != null) {
             Path path = Paths.get(mcPath);
@@ -120,4 +157,35 @@ private void setImpactVersion(InstallationConfig config, boolean checkMcVersionV
         }
         config.setSettingValue(ImpactVersionSetting.INSTANCE, version);
     }
+
+    // Get a properties file from the classpath
+    private static Properties getProperties(String filename) throws IOException {
+        Properties properties = new Properties();
+
+        InputStream inputStream = Args.class.getClassLoader().getResourceAsStream(filename);
+        if (inputStream == null) {
+            throw new FileNotFoundException(filename + "' not found in the classpath");
+        }
+
+        try {
+            properties.load(inputStream);
+        } finally {
+            inputStream.close();
+        }
+
+        return properties;
+    }
+
+    // Convert a string value to a primitive type
+    // Won't work for non-primitive types, but luckily all our args are primitives
+    private static Object toType(Class<?> type, String value ) {
+        if(Boolean.class == type || Boolean.TYPE == type) return Boolean.parseBoolean(value);
+        if(Byte.class == type || Byte.TYPE == type) return Byte.parseByte(value);
+        if(Short.class == type || Short.TYPE == type) return Short.parseShort(value);
+        if(Integer.class == type || Integer.TYPE == type) return Integer.parseInt(value);
+        if(Long.class == type || Long.TYPE == type) return Long.parseLong(value);
+        if(Float.class == type || Float.TYPE == type) return Float.parseFloat(value);
+        if(Double.class == type || Double.TYPE == type) return Double.parseDouble(value);
+        return value;
+    }
 }