gt:         String procName = "Q" + config.proc;
context: /* This file is part of VoltDB.
   * Copyright (C) 2008-2017 VoltDB Inc.
   *
   * Permission is hereby granted, free of charge, to any person obtaining
   * a copy of this software and associated documentation files (the
   * "Software"), to deal in the Software without restriction, including
   * without limitation the rights to use, copy, modify, merge, publish,
   * distribute, sublicense, and/or sell copies of the Software, and to
   * permit persons to whom the Software is furnished to do so, subject to
   * the following conditions:
   *
   * The above copyright notice and this permission notice shall be
   * included in all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
   * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
   * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
   * OTHER DEALINGS IN THE SOFTWARE.
   */
  
  package aggregationbenchmark;
  
  import java.io.FileWriter;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.atomic.AtomicBoolean;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.atomic.AtomicLong;
  import java.util.List;
  
  import org.voltdb.CLIConfig;
  import org.voltdb.VoltTable;
  import org.voltdb.client.Client;
  import org.voltdb.client.ClientConfig;
  import org.voltdb.client.ClientFactory;
  import org.voltdb.client.ClientResponse;
  import org.voltdb.client.ClientStats;
  import org.voltdb.client.ClientStatsContext;
  import org.voltdb.client.ClientStatusListenerExt;
  
  public class AggregationBenchmark {
  
      // handy, rather than typing this out several times
      static final String HORIZONTAL_RULE =
              "----------" + "----------" + "----------" + "----------" +
              "----------" + "----------" + "----------" + "----------" + "\n";
  
      // validated command line configuration
      final AggConfig config;
      // Reference to the database connection we will use
      final Client client;
  
      AtomicInteger total = new AtomicInteger();
  
      // Statistics manager objects from the client
      final ClientStatsContext fullStatsContext;
  
      /**
       * Uses included {@link CLIConfig} class to
       * declaratively state command line options with defaults
       * and validation.
       */
      static class AggConfig extends CLIConfig {
          @Option(desc = "Comma separated list of the form server[:port] to connect to.")
          String servers = "localhost";
  
          @Option(desc = "Number of invocations.")
          int invocations = 6;
  
          @Option(desc = "Restore the data from snapshot or not.")
          int restore = 0;
  
          @Option(desc = "Snapshot path.")
          String snapshotpath = "";
  
          @Option(desc = "Stored procedure number ( an integer from 1 to 20 )")
          int proc = 1;
  
          @Option(desc = "Filename to write raw summary statistics to.")
          String statsfile = "";
  
          @Override
          public void validate() {
              if (proc <= 0 || proc > 20) exitWithMessageAndUsage("procedure number must be in range [1, 20]");
          }
      }
  
      /**
       * Provides a callback to be notified on node failure.
       * This example only logs the event.
       */
      class StatusListener extends ClientStatusListenerExt {
          @Override
          public void connectionLost(String hostname, int port, int connectionsLeft, DisconnectCause cause) {
              // if the benchmark is still active
              System.err.printf("Connection to %s:%d was lost.\n", hostname, port);
          }
      }
  
      /**
       * Constructor for benchmark instance.
       * Configures VoltDB client and prints configuration.
       *
       * @param config Parsed & validated CLI options.
       */
      public AggregationBenchmark(AggConfig config) {
          this.config = config;
  
          ClientConfig clientConfig = new ClientConfig("", "", new StatusListener());
          //snapshot restore needs > default 2 minute timeout
          clientConfig.setProcedureCallTimeout(0);
  
          client = ClientFactory.createClient(clientConfig);
  
          fullStatsContext = client.createStatsContext();
  
          System.out.print(HORIZONTAL_RULE);
          System.out.println(" Command Line Configuration");
          System.out.println(HORIZONTAL_RULE);
          System.out.println(config.getConfigDumpString());
      }
  
      /**
       * Connect to a single server with retry. Limited exponential backoff.
       * No timeout. This will run until the process is killed if it's not
       * able to connect.
       *
       * @param server hostname:port or just hostname (hostname can be ip).
       */
      void connectToOneServerWithRetry(String server) {
          int sleep = 1000;
          while (true) {
              try {
                  client.createConnection(server);
  
                  break;
              }
              catch (Exception e) {
                  System.err.printf("Connection failed - retrying in %d second(s).\n", sleep / 1000);
                  try { Thread.sleep(sleep); } catch (Exception interruted) {}
                  if (sleep < 8000) sleep += sleep;
              }
          }
          System.out.printf("Connected to VoltDB node at: %s.\n", server);
      }
  
      /**
       * Connect to a set of servers in parallel. Each will retry until
       * connection. This call will block until all have connected.
       *
       * @param servers A comma separated list of servers using the hostname:port
       * syntax (where :port is optional).
       * @throws InterruptedException if anything bad happens with the threads.
       */
      void connect(String servers) throws InterruptedException {
          System.out.println("Connecting to VoltDB...");
  
          String[] serverArray = servers.split(",");
          final CountDownLatch connections = new CountDownLatch(serverArray.length);
  
          // use a new thread to connect to each server
          for (final String server : serverArray) {
              new Thread(new Runnable() {
                  @Override
                  public void run() {
                      connectToOneServerWithRetry(server);
                      connections.countDown();
                  }
              }).start();
          }
          // block until all have connected
          connections.await();
      }
  
      void restoreDatabase() throws Exception {
          ClientResponse resp = null;
          try {
              resp = client.callProcedure("@SnapshotRestore", config.snapshotpath, "TestBackupAggBench");
          } catch (Exception ex) {
              ex.printStackTrace();
              System.exit(-1);
          }
      }
  
      /**
       * Core benchmark code.
       * Connect. Initialize. Run the loop. Cleanup. Print Results.
       *
       * @throws Exception if anything unexpected happens.
       */
      public void runBenchmark() throws Exception {
          // connect to one or more servers, loop until success
          connect(config.servers);
  
          if (config.restore > 0) {
              System.out.println("\nLoading data from snapshot...");
              restoreDatabase();
          }
  
          FileWriter fw = null;
          if ((config.statsfile != null) && (config.statsfile.length() != 0)) {
              fw = new FileWriter(config.statsfile);
          }
  
          System.out.print(HORIZONTAL_RULE);
          System.out.println("\nRunning Benchmark");
          System.out.println(HORIZONTAL_RULE);
  
          // Benchmark start time
          long queryStartTS, queryElapse;
  
          int counter = config.invocations;
  