Updates to online recon for 2021 run

.gitignore

@@ -21,9 +21,6 @@ hs_err_pid*
 .settings
 nbproject
 
-# Maven target dir
-target
-
 # Diff output
 *.diff
 
@@ -40,4 +37,11 @@ ETBuffer
 
 deps.txt 
 
+# directories to ignore
 scratch/
+bin/
+target/
+
+
+# editor swap files
+.*.swp

online-recon/pom.xml

@@ -12,6 +12,10 @@
     <version>5.1-SNAPSHOT</version>
   </parent>
   <dependencies>
+    <dependency>
+      <groupId>org.hps</groupId>
+      <artifactId>hps-online-monitoring</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.hps</groupId>
       <artifactId>hps-recon</artifactId>
@@ -45,12 +49,27 @@
       <groupId>org.sonatype.nexus</groupId>
       <artifactId>google-guava-eventbus</artifactId>
       <version>3.2.0-01</version>
-  </dependency>
+    </dependency>
+    <dependency>
+      <groupId>org.java-websocket</groupId>
+      <artifactId>Java-WebSocket</artifactId>
+      <version>1.5.2</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.5</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-log4j12</artifactId>
+      <version>1.7.5</version>
+    </dependency>
   </dependencies>
   <build>
     <plugins>
       <!-- https://www.mojohaus.org/appassembler/appassembler-maven-plugin/ -->
-    <plugin>
+      <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>appassembler-maven-plugin</artifactId>
         <version>1.10</version>
@@ -74,35 +93,46 @@
               <mainClass>org.hps.online.recon.Server</mainClass>
               <id>online-recon-server</id>
               <jvmSettings>
-                <maxMemorySize>1g</maxMemorySize>
+                <maxMemorySize>4g</maxMemorySize>
+                <initialMemorySize>1g</initialMemorySize>
+                <maxStackSize>128m</maxStackSize>
                 <systemProperties>
                   <systemProperty>java.util.logging.config.class=org.hps.online.recon.logging.ServerLoggingConfig</systemProperty>
                 </systemProperties>
+                <extraArguments>
+                  <extraArgument>-XX:+UnlockExperimentalVMOptions</extraArgument>
+                  <extraArgument>-XX:+UseConcMarkSweepGC</extraArgument>
+                  <extraArgument>-XX:MaxGCPauseMillis=50</extraArgument>
+                  <extraArgument>-XX:G1HeapRegionSize=32M</extraArgument>
+                  <extraArgument>-XX:G1NewSizePercent=20</extraArgument>
+                  <extraArgument>-XX:G1ReservePercent=20</extraArgument>
+                  <extraArgument>-XX:SoftRefLRUPolicyMSPerMB=1</extraArgument>
+                </extraArguments>
               </jvmSettings>
             </program>
             <program>
               <mainClass>org.hps.online.recon.Client</mainClass>
               <id>online-recon-client</id>
               <jvmSettings>
-                <maxMemorySize>500m</maxMemorySize>
+                <maxMemorySize>200m</maxMemorySize>
                 <systemProperties>
                   <systemProperty>java.util.logging.config.class=org.hps.online.recon.logging.ClientLoggingConfig</systemProperty>
                 </systemProperties>
               </jvmSettings>
             </program>
             <program>
               <mainClass>org.hps.record.evio.EvioFileProducer</mainClass>
-              <id>hps-recon-producer</id>
+              <id>evio-producer</id>
               <jvmSettings>
-                <maxMemorySize>2g</maxMemorySize>
+                <maxMemorySize>1g</maxMemorySize>
                 <systemProperties>
                   <systemProperty>java.util.logging.config.class=org.hps.online.recon.logging.LoggingConfig</systemProperty>
                 </systemProperties>
               </jvmSettings>
             </program>
           </programs>
         </configuration>
-    </plugin>
+      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>

online-recon/src/main/java/org/hps/online/recon/Client.java

@@ -76,6 +76,21 @@ public final class Client {
      */
     private PrintWriter pw = null;
 
+    /**
+     * Command line arguments for the client
+     */
+    String[] clientArgs = null;
+
+    /**
+     * Arguments for the command to run on the server
+     */
+    String[] cmdArgs = null;
+
+    /**
+     * The client command (which may be null when opening a console or executing a file)
+     */
+    Command command = null;
+
     /**
      * The base options (commands have their own Options objects).
      */
@@ -84,9 +99,9 @@ public final class Client {
         OPTIONS.addOption(new Option("h", "help", false, "print help"));
         OPTIONS.addOption(new Option("p", "port", true, "server port"));
         OPTIONS.addOption(new Option("H", "host", true, "server hostname"));
-        OPTIONS.addOption(new Option("o", "output", true, "output file (default writes server responses to System.out)"));
+        OPTIONS.addOption(new Option("o", "output", true, "output file (default writes server responses to the console)"));
         OPTIONS.addOption(new Option("a", "append", false, "append if writing to output file (default will overwrite)"));
-        OPTIONS.addOption(new Option("i", "interactive", false, "start interactive console after executing command file"));
+        OPTIONS.addOption(new Option("i", "interactive", false, "start interactive console after executing a command file"));
     }
 
     /**
@@ -101,88 +116,129 @@ private Client() {
     private void printUsage() {
         final HelpFormatter help = new HelpFormatter();
         final String commands = String.join(" ", cf.getCommandNamesSorted());
-        help.printHelp(80, "Client [options] [[file] | [command] [command_options]]", "Send commands to the online reconstruction server",
+        help.printHelp(80, "Client [options] [[file] | [command] [command_options]]",
+                "Send commands to the online reconstruction server",
                 OPTIONS, "Commands: " + commands + '\n'
-                    + "Use 'Client [command] --help' for information about a specific command." + '\n'
                     + "Run with no client arguments to start the interactive console." + '\n'
                     + "Provide a file with commands as a single argument to execute it.");
     }
 
+    private void execFile(File file) {
+        // If there is a single argument, see if it looks like a command file to execute.
+        Console cn = new Console(this);
+        try {
+            cn.setEcho(true);
+            cn.execFile(file);
+            if (this.interactive) {
+                cn.setEcho(false);
+                cn.run();
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Error executing command file: " + file.getPath(), e);
+        }
+    }
+
+    /**
+     * Setup state from the raw command line arguments
+     *
+     * @param args The raw command line arguments
+     */
+    private void setup(String args[]) {
+        int cmdIdx = findCommand(args);
+        clientArgs = args;
+        if (cmdIdx > 0) {
+            String commandName = args[cmdIdx];
+            command = cf.create(commandName);
+            clientArgs = new String[0];
+            if (cmdIdx > 0) {
+                clientArgs = new String[cmdIdx];
+                System.arraycopy(args, 0, clientArgs, 0, cmdIdx);
+            } else {
+                clientArgs = new String[0];
+            }
+
+            cmdArgs = new String[0];
+            if (args.length - cmdIdx - 1 > 0) {
+                cmdArgs = new String[args.length - cmdIdx];
+                System.arraycopy(args, cmdIdx + 1, cmdArgs, 0, args.length - cmdIdx);
+            }
+        }
+
+        /*
+        if (clientArgs.length > 0) {
+            List<String> clientArgList = Arrays.asList(clientArgs);
+            LOG.info("Client arg list: " + String.join(" ", clientArgList));
+        }
+
+        if (cmdArgs != null) {
+            List<String> cmdArgList = Arrays.asList(cmdArgs);
+            LOG.info("Command arg list: " + String.join(" ", cmdArgList));
+        }
+        */
+    }
+
     /**
-     * Run the client using command line arguments
+     * Run the client using command line arguments.
+     *
      * @param args The command line arguments
      */
     void run(String args[]) {
 
-        List<String> argList = parseOptions(args);
+        // Find the client command to run if provided and set various other state
+        setup(args);
 
-        // If extra arguments are provided then try to run a command.
-        if (argList.size() != 0) {
+        // Parse the client options
+        List<String> extraArgs = parseOptions(clientArgs);
 
-            // See if a command was provided.
-            String commandName = argList.get(0);
+        if (command != null) {
+            // Run a client command if one was provided
 
-            if (cf.commandExists(commandName)) {
+            LOG.info("Executing client command " + command.getName());
 
-                Command command = cf.create(commandName);
-
-                // Remove command from arg list.
-                argList.remove(0);
+            try {
+                command.parse(cmdArgs);
+            } catch (ParseException e) {
+                throw new RuntimeException(e);
+            }
 
-                // Convert command list to array.
-                String[] argArr = argList.toArray(new String[0]);
+            // Setup the command parameters from the parsed options.
+            command.process();
 
-                // Parse command options.
-                DefaultParser commandParser = new DefaultParser();
-                CommandLine cmdResult = null;
-                try {
-                    cmdResult = commandParser.parse(command.getOptions(), argArr);
+            // Send the command to server.
+            LOG.info("Sending command " + command.toString());
+            send(command);
 
-                    // Print usage of the command and exit.
-                    if (cmdResult.hasOption("help")) {
-                        command.printUsage();
-                        System.exit(0);
-                    }
-                } catch (ParseException e) {
-                    command.printUsage();
-                    throw new RuntimeException("Error parsing command options", e);
-                }
+        } else if (extraArgs.size() > 0) {
+            // Execute a file with client commands using the Console
 
-                // Setup the command parameters from the parsed options.
-                command.process(cmdResult);
+            LOG.info("Extra args: " + String.join(" ", extraArgs));
 
-                // Send the command to server.
-                LOG.info("Sending command " + command.toString());
-                send(command);
-            } else {
-                // If there is a single argument, see if it looks like a command file to execute.
-                File execFile = new File(argList.get(0));
-                if (argList.size() == 1 && execFile.exists()) {
-                    Console cn = new Console(this);
-                    try {
-                        cn.setEcho(true);
-                        cn.execFile(execFile);
-                        if (this.interactive) {
-                            cn.setEcho(false);
-                            cn.run();
-                        }
-                    } catch (Exception e) {
-                        throw new RuntimeException("Error executing command file: " + execFile.getPath(), e);
-                    }
-                } else {
-                    // Could not parse command line options.
-                    printUsage();
-                    throw new IllegalArgumentException("Unknown command: " + commandName);
-                }
-            }
+            execFile(new File(extraArgs.get(0)));
         } else {
             // No command was provided so run the interactive console.
             Console cn = new Console(this);
             cn.run();
         }
     }
 
+    /**
+     * Find a client command in the raw arguments
+     * @param args
+     * @return
+     */
+    private int findCommand(String[] args) {
+        int idx = -1;
+        for (int i = 0; i < args.length; i++) {
+            if (cf.commandExists(args[i])) {
+                idx = i;
+                break;
+            }
+        }
+        return idx;
+    }
+
     private List<String> parseOptions(String[] args) {
+
         // Parse base options.
         CommandLine cl;
         try {
@@ -197,9 +253,6 @@ private List<String> parseOptions(String[] args) {
             System.exit(0);
         }
 
-        // Get extra arg list.
-        List<String> argList = cl.getArgList();
-
         if (cl.hasOption("p")) {
             this.port = Integer.parseInt(cl.getOptionValue("p"));
             LOG.config("Port: " + this.port);
@@ -231,7 +284,8 @@ private List<String> parseOptions(String[] args) {
             this.interactive = true;
             LOG.config("Interactive mode enable: " + this.interactive);
         }
-        return argList;
+
+        return cl.getArgList();
     }
 
     /**