add command line interface to the control panel

2010-12-20  Omair Majid  <[email protected]>

    * Makefile.am
    ($(NETX_DIR)/launcher/controlpanel/%.o): Set program name, and launch
    net.sourceforge.jnlp.controlpanel.CommandLine.
    * netx/net/sourceforge/jnlp/config/Defaults.java
    (getDefaults): Set descriptions to Unknown rather than the name.
    Set source to localized form of internal.
    * netx/net/sourceforge/jnlp/config/DeploymentConfiguration.java
    (getProperty): Check for nulls.
    (setProperty): Add unknown as description and source for new
    properties.
    (checkAndFixConfiguration): Fix translation constants.
    (parsePropertiesFile): Use unknown as description.
    * netx/net/sourceforge/jnlp/controlpanel/CommandLine.java: New file
    (CommandLine): New method.
    (handleHelpCommand): Likewise.
    (printListHelp): Likewise.
    (handleListCommand): Likewise.
    (printGetHelp): Likewise.
    (handleGetCommand): Likewise.
    (printSetHelp): Likewise.
    (handleSetCommand): Likewise.
    (printResetHelp): Likewise.
    (handleResetCommand): Likewise.
    (printInfoHelp): Likewise.
    (handleInfoCommand): Likewise.
    (printCheckHelp): Likewise.
    (handleCheckCommand): Likewise.
    (handle): Likewise.
    (main): Likewise.
    * netx/net/sourceforge/jnlp/resources/Messages.properties: Add
    Usage, Unknown, RConfigurationFatal, DCIncorrectValue,
    DCSourceInternal, DCUnknownSettingWithName, VVPossibleValues,
    CLNoInfo, CLValue, CLValueSource, CLDescription, CLUnknownCommand
    CLUnknownProperty, CLNoIssuesFound, CLIncorrectValue,
    CLListDescription, CLGetDescription, CLSetDescription,
    CLResetDescription, CLInfoDescription, CLCheckDescription and
    CLHelpDescription. Remove DCErrorInSetting and
    DCUnknownSettingWithVal.

1 files changed, 456 insertions, 0 deletions

diff --git a/netx/net/sourceforge/jnlp/controlpanel/CommandLine.java b/netx/net/sourceforge/jnlp/controlpanel/CommandLine.java
new file mode 100644
index 0000000..0e4f1d0
--- /dev/null
+++ b/netx/net/sourceforge/jnlp/controlpanel/CommandLine.java
@@ -0,0 +1,456 @@
+/* CommandLine.java -- command line interface to icedtea-web's deployment settings.
+Copyright (C) 2010 Red Hat
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+package net.sourceforge.jnlp.controlpanel;
+
+import static net.sourceforge.jnlp.runtime.Translator.R;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import javax.naming.ConfigurationException;
+
+import net.sourceforge.jnlp.config.ConfiguratonValidator;
+import net.sourceforge.jnlp.config.DeploymentConfiguration;
+import net.sourceforge.jnlp.config.Setting;
+
+/**
+ * Encapsulates a command line interface to the deployment configuration.
+ * <p>
+ * The central method is {@link #handle(String[])}, which calls one of the
+ * various 'handle' methods. The commands listed in {@link #allCommands} are
+ * supported. For each supported command, a method handleCOMMANDCommand exists.
+ * This method actually takes action based on the command. Generally, a
+ * printCOMMANDHelp method also exists, and prints out the help message for
+ * that specific command. For example, see {@link #handleListCommand(List)}
+ * and {@link #printListHelp()}.
+ * <p>
+ * Sample usage:
+ * <pre>
+ * CommandLine cli = new CommandLine();
+ * // the string array represents input using the command line
+ * int retVal = cli.handle(new String[] { "help" });
+ * if (retVal == CommandLine.SUCCESS) {
+ *    // good!
+ * } else {
+ *    // bad!
+ * }
+ * </pre>
+ *
+ * @author Omair Majid ([email protected])
+ */
+public class CommandLine {
+
+    public static final int ERROR = 1;
+    public static final int SUCCESS = 0;
+
+    public final String PROGRAM_NAME;
+
+    private static final List<String> allCommands = Arrays.asList(new String[] {
+            "list", "get", "set", "reset", "info", "check"
+    });
+
+    DeploymentConfiguration config = null;
+
+    /**
+     * Creates a new instance
+     */
+    public CommandLine() {
+        PROGRAM_NAME = System.getProperty("program.name");
+
+        config = new DeploymentConfiguration();
+        try {
+            config.load(false);
+        } catch (ConfigurationException e) {
+            System.out.println(R("RConfigurationFatal"));
+        }
+    }
+
+    /**
+     * Handle the 'help' command
+     *
+     * @param args optional
+     * @return the result of handling the help command. SUCCESS if no errors occurred.
+     */
+    public int handleHelpCommand(List<String> args) {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " "
+                + allCommands.toString().replace(',', '|').replaceAll(" ", "") + " [help]");
+        System.out.println(R("CLHelpDescription", PROGRAM_NAME));
+        return SUCCESS;
+    }
+
+    /**
+     * Prints help message for the list command
+     */
+    public void printListHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " list [--details]");
+        System.out.println(R("CLListDescription"));
+    }
+
+    /**
+     * Handles the 'list' command
+     *
+     * @param args the arguments to the list command
+     * @return result of handling the command. SUCCESS if no errors occurred.
+     */
+    public int handleListCommand(List<String> args) {
+        if (args.contains("help")) {
+            printListHelp();
+            return SUCCESS;
+        }
+
+        boolean verbose = false;
+
+        if (args.contains("--details")) {
+            verbose = true;
+            args.remove("--details");
+        }
+
+        if (args.size() != 0) {
+            printListHelp();
+            return ERROR;
+        }
+
+        Map<String, Setting<String>> all = config.getRaw();
+        for (String key : all.keySet()) {
+            Setting<String> value = all.get(key);
+            System.out.println(key + ": " + value.getValue());
+            if (verbose) {
+                System.out.println("\t" + R("CLDescription", value.getDescription()));
+            }
+        }
+        return SUCCESS;
+    }
+
+    /**
+     * Prints help message for the get command
+     */
+    public void printGetHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " get property-name");
+        System.out.println(R("CLGetDescription"));
+    }
+
+    /**
+     * Handles the 'get' command.
+     *
+     * @param args the arguments to the get command
+     * @return an integer representing success (SUCCESS) or error handling the
+     * get command.
+     */
+    public int handleGetCommand(List<String> args) {
+        if (args.contains("help")) {
+            printGetHelp();
+            return SUCCESS;
+        }
+
+        if (args.size() != 1) {
+            printGetHelp();
+            return ERROR;
+        }
+
+        Map<String, Setting<String>> all = config.getRaw();
+
+        String key = args.get(0);
+        String value = null;
+        if (all.containsKey(key)) {
+            value = all.get(key).getValue();
+            System.out.println(value);
+            return SUCCESS;
+        } else {
+            System.out.println(R("CLUnknownProperty", key));
+            return ERROR;
+        }
+    }
+
+    /**
+     * Prints the help message for the 'set' command
+     */
+    public void printSetHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " set property-name value");
+        System.out.println(R("CLSetDescription"));
+    }
+
+    /**
+     * Handles the 'set' command
+     *
+     * @param args the arguments to the set command
+     * @return an integer indicating success (SUCCESS) or error in handling
+     * the command
+     */
+    public int handleSetCommand(List<String> args) {
+        if (args.contains("help")) {
+            printSetHelp();
+            return SUCCESS;
+        }
+
+        if (args.size() != 2) {
+            printSetHelp();
+            return ERROR;
+        }
+
+        String key = args.get(0);
+        String value = args.get(1);
+
+        if (config.getRaw().containsKey(key)) {
+            Setting<String> old = config.getRaw().get(key);
+            if (old.getValidator() != null) {
+                try {
+                    old.getValidator().validate(value);
+                } catch (IllegalArgumentException e) {
+                    System.out.println(R("CLIncorrectValue", old.getName(), value, old.getValidator().getPossibleValues()));
+                    return ERROR;
+                }
+            }
+            config.setProperty(key, value);
+        } else {
+            System.out.println(R("CLUnknownProperty", value));
+            config.setProperty(key, value);
+        }
+
+        try {
+            config.save();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return ERROR;
+        }
+
+        return SUCCESS;
+    }
+
+    /**
+     * Prints a help message for the reset command
+     */
+    public void printResetHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " reset property-name");
+        System.out.println(R("CLResetDescription"));
+    }
+
+    /**
+     * Handles the 'reset' command
+     *
+     * @param args the arguments to the reset command
+     * @return an integer indicating success (SUCCESS) or error in handling
+     * the command
+     */
+    public int handleResetCommand(List<String> args) {
+        if (args.contains("help")) {
+            printResetHelp();
+            return SUCCESS;
+        }
+
+        if (args.size() != 1) {
+            printResetHelp();
+            return ERROR;
+        }
+
+        String key = args.get(0);
+
+        Map<String, Setting<String>> all = config.getRaw();
+        if (!all.containsKey(key)) {
+            System.out.println(R("CLUnknownProperty", key));
+            return ERROR;
+        }
+
+        Setting<String> setting = all.get(key);
+        setting.setValue(setting.getDefaultValue());
+
+        try {
+            config.save();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return ERROR;
+        }
+
+        return SUCCESS;
+    }
+
+    /**
+     * Print a help message for the 'info' command
+     */
+    public void printInfoHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " info property-name");
+        System.out.println(R("CLInfoDescription"));
+    }
+
+    /**
+     * Handles the 'info' command
+     *
+     * @param args the arguments to the info command
+     * @return an integer indicating success (SUCCESS) or error in handling
+     * the command
+     */
+    public int handleInfoCommand(List<String> args) {
+        if (args.contains("help")) {
+            printInfoHelp();
+            return SUCCESS;
+        }
+
+        if (args.size() != 1) {
+            printInfoHelp();
+            return ERROR;
+        }
+
+        Map<String, Setting<String>> all = config.getRaw();
+
+        String key = args.get(0);
+        Setting<String> value = all.get(key);
+        if (value == null) {
+            System.out.println(R("CLNoInfo"));
+            return ERROR;
+        } else {
+            System.out.println(R("CLDescription", value.getDescription()));
+            System.out.println(R("CLValue", value.getValue()));
+            if (value.getValidator() != null) {
+                System.out.println("\t" + R("VVPossibleValues", value.getValidator().getPossibleValues()));
+            }
+            System.out.println(R("CLValueSource", value.getSource()));
+            return SUCCESS;
+        }
+    }
+
+    /**
+     * Prints a help message for the 'check' command
+     */
+    public void printCheckHelp() {
+        System.out.println(R("Usage"));
+        System.out.println("  " + PROGRAM_NAME + " check");
+        System.out.println(R("CLCheckDescription"));
+    }
+
+    /**
+     * Handles the 'check' command
+     *
+     * @param args the arguments to the check command.
+     * @return an integer indicating success (SUCCESS) or error in handling
+     * the command
+     */
+    public int handleCheckCommand(List<String> args) {
+        if (args.contains("help")) {
+            printCheckHelp();
+            return SUCCESS;
+        }
+
+        if (args.size() != 0) {
+            printCheckHelp();
+            return ERROR;
+        }
+
+        Map<String, Setting<String>> all = config.getRaw();
+
+        ConfiguratonValidator validator = new ConfiguratonValidator(all);
+        validator.validate();
+
+        boolean allValid = true;
+        for (Setting<String> setting : validator.getIncorrectSetting()) {
+            System.out.println(R("CLIncorrectValue", setting.getName(), setting.getValue(), setting.getValidator().getPossibleValues()));
+            allValid = false;
+        }
+
+        for (Setting<String> setting : validator.getUnrecognizedSetting()) {
+            System.out.println(R("CLUnknownProperty", setting.getName()));
+            allValid = false;
+        }
+
+        if (allValid) {
+            System.out.println(R("CLNoIssuesFound"));
+            return SUCCESS;
+        } else {
+            return ERROR;
+        }
+    }
+
+    /**
+     * Handles overall command line arguments. The argument array is split
+     * into two pieces: the first element is assumend to be the command, and
+     * everything after is taken to be the argument to the command.
+     *
+     * @param commandAndArgs A string array representing the command and
+     * arguments to take action on
+     * @return an integer representing an error code or SUCCESS if no problems
+     * occurred.
+     */
+    public int handle(String[] commandAndArgs) {
+
+        if (commandAndArgs == null) {
+            throw new NullPointerException("command is null");
+        }
+
+        if (commandAndArgs.length == 0) {
+            handleHelpCommand(new ArrayList<String>());
+            return ERROR;
+        }
+
+        String command = commandAndArgs[0];
+        String[] argsArray = new String[commandAndArgs.length - 1];
+        System.arraycopy(commandAndArgs, 1, argsArray, 0, commandAndArgs.length - 1);
+        List<String> arguments = new ArrayList<String>(Arrays.asList(argsArray));
+
+        int val;
+        if (command.equals("help")) {
+            val = handleHelpCommand(arguments);
+        } else if (command.equals("list")) {
+            val = handleListCommand(arguments);
+        } else if (command.equals("set")) {
+            val = handleSetCommand(arguments);
+        } else if (command.equals("reset")) {
+            val = handleResetCommand(arguments);
+        } else if (command.equals("get")) {
+            val = handleGetCommand(arguments);
+        } else if (command.equals("info")) {
+            val = handleInfoCommand(arguments);
+        } else if (command.equals("check")) {
+            val = handleCheckCommand(arguments);
+        } else if (allCommands.contains(command)) {
+            System.out.println("INTERNAL ERROR: " + command + " should have been implemented");
+            val = ERROR;
+        } else {
+            System.out.println(R("CLUnknownCommand", command));
+            handleHelpCommand(new ArrayList<String>());
+            val = ERROR;
+        }
+
+        return val;
+    }
+
+    /**
+     * The starting point of the program
+     * @param args the command line arguments to this program
+     */
+    public static void main(String[] args) throws Exception {
+        if (args.length == 0) {
+            ControlPanel.main(new String[] {});
+        } else {
+            CommandLine cli = new CommandLine();
+            int result = cli.handle(args);
+
+            // instead of returning, use System.exit() so we can pass back
+            // error codes indicating success or failure. Otherwise using
+            // this program for scripting will become much more challenging
+            System.exit(result);
+        }
+    }
+}