Add better support for command line arguments (#702)

Author: SamCarlberg

build.gradle

@@ -260,6 +260,7 @@ project(":core") {
         testCompile group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.2'
         testCompile group: 'org.apache.httpcomponents', name: 'httpcore', version: '4.2.2'
         testCompile group: 'org.apache.httpcomponents', name: 'httpmime', version: '4.5.2'
+        compile group: 'commons-cli', name: 'commons-cli', version: '1.3.1'
         // We use the no_aop version of Guice because the aop isn't avaiable in arm java
         // http://stackoverflow.com/a/15235190/3708426
         // https://github.com/google/guice/wiki/OptionalAOP
@@ -275,6 +276,12 @@ project(":core") {
 
     mainClassName = 'edu.wpi.grip.core.Main'
 
+    if (project.hasProperty('args')) {
+        run {
+            args = (project.args.split("\\s+") as List)
+        }
+    }
+
     jar {
         manifest {
             attributes 'Implementation-Version': version, 'Main-Class': mainClassName
@@ -438,6 +445,12 @@ project(":ui") {
         }
     }
 
+    if (project.hasProperty('args')) {
+        run {
+            args = (project.args.split("\\s+") as List)
+        }
+    }
+
     task testSharedLib() {
         description 'Compiles the shared library used by c++ generation testing.'
         doLast {

core/src/main/java/edu/wpi/grip/core/CoreCommandLineHelper.java

@@ -0,0 +1,137 @@
+package edu.wpi.grip.core;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+
+import java.util.List;
+
+/**
+ * A helper class for command line options for GRIP.
+ */
+public class CoreCommandLineHelper {
+
+  public static final String FILE_OPTION = "f"; // "f" for "file"
+  public static final String PORT_OPTION = "p"; // "p" for "port"
+  public static final String HELP_OPTION = "h"; // "h" for "help" (this is standard)
+  public static final String VERSION_OPTION = "v"; // "v" for "version" (this is standard)
+
+  private final Options options = new Options();
+  private static final Option saveOption =
+      Option.builder(FILE_OPTION)
+          .longOpt("file")
+          .desc("Set the GRIP save file to load")
+          .hasArg()
+          .numberOfArgs(1)
+          .argName("path")
+          .build();
+  private static final Option portOption =
+      Option.builder(PORT_OPTION)
+          .longOpt("port")
+          .desc("Set the port to run the HTTP server on")
+          .hasArg()
+          .numberOfArgs(1)
+          .argName("port")
+          .build();
+  private static final Option helpOption
+      = new Option(HELP_OPTION, "help", false, "Prints the command line options");
+  private static final Option versionOption
+      = new Option(VERSION_OPTION, "version", false, "Prints the version of GRIP");
+
+  /**
+   * Creates a new core commandline helper with the standard options.
+   */
+  public CoreCommandLineHelper() {
+    options.addOption(saveOption);
+    options.addOption(portOption);
+    options.addOption(helpOption);
+    options.addOption(versionOption);
+  }
+
+  /**
+   * Creates a command line helper with all the standard options, plus any additional options
+   * required by subclasses.
+   *
+   * @param additionalOptions additional command line arguments
+   */
+  protected CoreCommandLineHelper(Option... additionalOptions) {
+    this();
+    for (Option o : additionalOptions) {
+      options.addOption(o);
+    }
+  }
+
+  /**
+   * Parses an array of command line arguments. If there are unknown arguments or the arguments are
+   * otherwise malformed, a help message will be printed and the application will exit without
+   * returning from this method. This will also occur if the help option is specified.
+   *
+   * @param args the command line arguments to parse
+   *
+   * @return a CommandLine object that can be queried for command line options and their values
+   */
+  @SuppressWarnings({"checkstyle:regexp", "PMD.SystemPrintln"})
+  public CommandLine parse(String... args) {
+    try {
+      DefaultParser parser = new DefaultParser();
+      CommandLine parsed = parser.parse(options, args);
+      if (parsed.hasOption(HELP_OPTION)) {
+        printHelpAndExit();
+      } else if (parsed.hasOption(VERSION_OPTION)) {
+        printVersionAndExit();
+      }
+      return parsed;
+    } catch (ParseException e) {
+      System.out.println("Incorrect command line arguments: " + e.getMessage());
+      printHelpAndExit();
+    }
+    return null; // This is OK -- will only happen in tests
+  }
+
+  /**
+   * Parses a list of command line arguments. This coverts the list to an array and passes it to
+   * {@link #parse(String[])}.
+   *
+   * @see #parse(String[])
+   */
+  public CommandLine parse(List<String> args) {
+    return parse(args.toArray(new String[args.size()]));
+  }
+
+  /**
+   * Prints a help message for the command line arguments and exits the application.
+   */
+  @VisibleForTesting
+  void printHelpAndExit() {
+    HelpFormatter hf = new HelpFormatter();
+    hf.printHelp("GRIP", options);
+    exit();
+  }
+
+  /**
+   * Prints the app version and exits the application.
+   */
+  @VisibleForTesting
+  @SuppressWarnings({"checkstyle:regexp", "PMD.SystemPrintln"})
+  void printVersionAndExit() {
+    System.out.printf(
+        "GRIP version %s%n",
+        CoreCommandLineHelper.class.getPackage().getImplementationVersion()
+    );
+    exit();
+  }
+
+  /**
+   * Exits the app. This method only exists so testing can work.
+   */
+  @VisibleForTesting
+  void exit() {
+    System.exit(0);
+  }
+
+}

core/src/main/java/edu/wpi/grip/core/Main.java

@@ -12,10 +12,13 @@
 
 import com.google.common.eventbus.EventBus;
 import com.google.common.eventbus.Subscribe;
+import com.google.common.util.concurrent.Service;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
 import com.google.inject.util.Modules;
 
+import org.apache.commons.cli.CommandLine;
+
 import java.io.File;
 import java.io.IOException;
 import java.util.logging.Level;
@@ -47,30 +50,58 @@ public class Main {
 
   @SuppressWarnings("JavadocMethod")
   public static void main(String[] args) throws IOException, InterruptedException {
+    new CoreCommandLineHelper().parse(args); // Check for help or version before doing anything else
     final Injector injector = Guice.createInjector(Modules.override(new GripCoreModule(),
         new GripFileModule(), new GripSourcesHardwareModule()).with(new GripNetworkModule()));
     injector.getInstance(Main.class).start(args);
   }
 
   @SuppressWarnings("JavadocMethod")
   public void start(String[] args) throws IOException, InterruptedException {
-    String projectPath = null;
-    if (args.length == 1) {
-      logger.log(Level.INFO, "Loading file " + args[0]);
-      projectPath = args[0];
-    }
 
     operations.addOperations();
     cvOperations.addOperations();
     gripServer.addHandler(pipelineSwitcher);
-    gripServer.start();
 
-    // Open a project from a .grip file specified on the command line
-    if (projectPath != null) {
-      project.open(new File(projectPath));
+    CoreCommandLineHelper commandLineHelper = new CoreCommandLineHelper();
+    CommandLine parsedArgs = commandLineHelper.parse(args);
+
+    // Parse the save file option
+    if (parsedArgs.hasOption(CoreCommandLineHelper.FILE_OPTION)) {
+      // Open a project from a .grip file specified on the command line
+      String file = parsedArgs.getOptionValue(CoreCommandLineHelper.FILE_OPTION);
+      logger.log(Level.INFO, "Loading file " + file);
+      project.open(new File(file));
     }
 
-    pipelineRunner.startAsync();
+    // Set the port AFTER loading the project to override the saved port number
+    if (parsedArgs.hasOption(CoreCommandLineHelper.PORT_OPTION)) {
+      try {
+        int port = Integer.parseInt(parsedArgs.getOptionValue(CoreCommandLineHelper.PORT_OPTION));
+        if (port < 1024 || port > 65535) {
+          logger.warning("Not a valid port: " + port);
+        } else {
+          // Valid port; set it (Note: this doesn't check to see if the port is available)
+          logger.info("Running server on port " + port);
+          gripServer.setPort(port);
+        }
+      } catch (NumberFormatException e) {
+        logger.warning(
+            "Not a valid port: " + parsedArgs.getOptionValue(CoreCommandLineHelper.PORT_OPTION));
+      }
+    }
+
+    // This will throw an exception if the port specified by the save file or command line
+    // argument is already taken. Since we have to have the server running to handle remotely
+    // loading pipelines and uploading images, as well as potential HTTP publishing operations,
+    // this will cause the program to exit.
+    gripServer.start();
+
+    if (pipelineRunner.state() == Service.State.NEW) {
+      // Loading a project will start the pipeline, so only start it if a project wasn't specified
+      // as a command line argument.
+      pipelineRunner.startAsync();
+    }
 
     // This is done in order to indicate to the user using the deployment UI that this is running
     logger.log(Level.INFO, "SUCCESS! The project is running in headless mode!");

core/src/main/java/edu/wpi/grip/core/http/GripServer.java

@@ -212,10 +212,12 @@ public State getState() {
    *
    * @param port the new port to run on.
    */
-  private void setPort(int port) {
+  public void setPort(int port) {
     stop();
     server = serverFactory.create(port);
+    server.setHandler(handlers);
     state = State.PRE_RUN;
+    start();
   }
 
   /**
@@ -230,7 +232,6 @@ public void settingsChanged(ProjectSettingsChangedEvent event) {
     int port = event.getProjectSettings().getServerPort();
     if (port != getPort()) {
       setPort(port);
-      server.setHandler(handlers);
       start();
     }
   }

core/src/test/java/edu/wpi/grip/core/CoreCommandLineHelperTest.java

@@ -0,0 +1,73 @@
+package edu.wpi.grip.core;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class CoreCommandLineHelperTest {
+
+  private static class MockHelper extends CoreCommandLineHelper {
+    @Override
+    void exit() {
+      // NOP
+    }
+  }
+
+  @Test
+  public void testHelp() {
+    boolean[] printed = {false};
+    boolean[] exited = {false};
+    MockHelper m = new MockHelper() {
+      @Override
+      void printHelpAndExit() {
+        printed[0] = true;
+        super.printHelpAndExit();
+      }
+
+      @Override
+      void exit() {
+        exited[0] = true;
+      }
+    };
+    m.parse("-h");
+    assertTrue("Help text was not printed", printed[0]);
+    assertTrue("The application didn't exit", exited[0]);
+    printed[0] = false;
+    exited[0] = false;
+    m.parse("--help");
+    assertTrue("Help text was not printed", printed[0]);
+    assertTrue("The application didn't exit", exited[0]);
+    printed[0] = false;
+    exited[0] = false;
+    m.parse("--port"); // No value given, should print help text and exit
+    assertTrue("Help text was not printed", printed[0]);
+    assertTrue("The application didn't exit", exited[0]);
+  }
+
+  @Test
+  public void testVersion() {
+    boolean[] printed = {false};
+    boolean[] exited = {false};
+    MockHelper m = new MockHelper() {
+      @Override
+      void printVersionAndExit() {
+        printed[0] = true;
+        super.printVersionAndExit();
+      }
+
+      @Override
+      void exit() {
+        exited[0] = true;
+      }
+    };
+    m.parse("-v");
+    assertTrue("Version text was not printed", printed[0]);
+    assertTrue("The application didn't exit", exited[0]);
+    printed[0] = false;
+    exited[0] = false;
+    m.parse("--version");
+    assertTrue("Version text was not printed", printed[0]);
+    assertTrue("The application didn't exit", exited[0]);
+  }
+
+}

core/src/test/java/edu/wpi/grip/core/CoreSanityTest.java

@@ -26,7 +26,8 @@ public CoreSanityTest() {
         AddOperation.class,
         ManualPipelineRunner.class,
         SubtractionOperation.class,
-        Main.class
+        Main.class,
+        CoreCommandLineHelper.class
     ).contains(c));
     setDefault(OutputSocket.class, new MockOutputSocket("Mock Out"));
     setDefault(InputSocket.class, new MockInputSocket("Mock In"));