// TODO add exception for invalid options
  private void loadCLO(String[] args) {
    Options options = new Options();

    String[][] clolist = {
      // {"variable/optionname", "description"},
      {"genConfig", "general configuration file location"},
      {"inWeightsLoc", "input weights configuration file location"},
      {"inDBLoc", "input database file location"},
      {"outWeightsLoc", "output weights configuration file location"},
      {"outDBLoc", "output database file location"},
      {"p3pLocation", "adding to DB: single policy file location"},
      {"p3pDirLocation", "adding to DB: multiple policy directory location"},
      {"newDB", "create new database in place of old one (doesn't check for existence of old one"},
      {"newPolicyLoc", "the policy object to process"},
      {"userResponse", "response to specified policy"},
      {"userIO", "user interface"},
      {"userInit", "initialization via user interface"},
      {"policyDB", "PolicyDatabase backend"},
      {"cbrV", "CBR to use"},
      {"blanketAccept", "automatically accept the user suggestion"},
      {"loglevel", "level of things save to the log- see java logging details"},
      {"policyDB", "PolicyDatabase backend"},
      {"NetworkRType", "Network Resource type"},
      {"NetworkROptions", "Network Resource options"},
      {"confidenceLevel", "Confidence threshold for consulting a networked resource"},
      {"useNet", "use networking options"},
      {"loglocation", "where to save the log file"},
      {"loglevel", "the java logging level to use. See online documentation for enums."}
    };

    for (String[] i : clolist) {
      options.addOption(i[0], true, i[1]);
    }

    CommandLineParser parser = new PosixParser();
    CommandLine cmd = null;
    try {
      cmd = parser.parse(options, args);
    } catch (ParseException e) {
      System.err.println("Error parsing commandline arguments.");
      e.printStackTrace();
      System.exit(3);
    }
    /*
    for(String i : args)
    {
    	System.err.println(i);
    }
    */
    for (String[] i : clolist) {
      if (cmd.hasOption(i[0])) {
        System.err.println("found option i: " + i);
        genProps.setProperty(i[0], cmd.getOptionValue(i[0]));
      }
    }
    System.err.println(genProps);
  }
Beispiel #2
0
  protected Util(String[] args) {
    CommandLineParser cmdLineParse = new PosixParser();

    Options options = new Options();
    options.addOption("h", "help", false, "show this help message and exit");
    options.addOption(
        OptionBuilder.withLongOpt("host")
            .withDescription("host to connect to (default 0.0.0.0)")
            .hasArg(true)
            .withArgName("HOST")
            .create('H'));
    options.addOption(
        OptionBuilder.withLongOpt("username")
            .withDescription("username to use for authentication")
            .hasArg(true)
            .withArgName("USERNAME")
            .create('u'));
    options.addOption(
        OptionBuilder.withLongOpt("password")
            .withDescription("password to use for authentication")
            .hasArg(true)
            .withArgName("PASSWORD")
            .create('w'));
    options.addOption(
        OptionBuilder.withLongOpt("port")
            .withDescription("port to connect to (default 5672)")
            .hasArg(true)
            .withArgName("PORT")
            .create('p'));
    options.addOption(
        OptionBuilder.withLongOpt("frame-size")
            .withDescription("specify the maximum frame size")
            .hasArg(true)
            .withArgName("FRAME_SIZE")
            .create('f'));
    options.addOption(
        OptionBuilder.withLongOpt("container-name")
            .withDescription("Container name")
            .hasArg(true)
            .withArgName("CONTAINER_NAME")
            .create('C'));

    options.addOption(OptionBuilder.withLongOpt("ssl").withDescription("Use SSL").create('S'));

    options.addOption(
        OptionBuilder.withLongOpt("remote-hostname")
            .withDescription("hostname to supply in the open frame")
            .hasArg(true)
            .withArgName("HOST")
            .create('O'));

    if (hasBlockOption())
      options.addOption(
          OptionBuilder.withLongOpt("block")
              .withDescription("block until messages arrive")
              .create('b'));

    if (hasCountOption())
      options.addOption(
          OptionBuilder.withLongOpt("count")
              .withDescription("number of messages to send (default 1)")
              .hasArg(true)
              .withArgName("COUNT")
              .create('c'));
    if (hasModeOption())
      options.addOption(
          OptionBuilder.withLongOpt("acknowledge-mode")
              .withDescription(
                  "acknowledgement mode: AMO|ALO|EO (At Least Once, At Most Once, Exactly Once")
              .hasArg(true)
              .withArgName("MODE")
              .create('k'));

    if (hasSubjectOption())
      options.addOption(
          OptionBuilder.withLongOpt("subject")
              .withDescription("subject message property")
              .hasArg(true)
              .withArgName("SUBJECT")
              .create('s'));

    if (hasSingleLinkPerConnectionMode())
      options.addOption(
          OptionBuilder.withLongOpt("single-link-per-connection")
              .withDescription(
                  "acknowledgement mode: AMO|ALO|EO (At Least Once, At Most Once, Exactly Once")
              .hasArg(false)
              .create('Z'));

    if (hasFilterOption())
      options.addOption(
          OptionBuilder.withLongOpt("filter")
              .withDescription("filter, e.g. exact-subject=hello; matching-subject=%.a.#")
              .hasArg(true)
              .withArgName("<TYPE>=<VALUE>")
              .create('F'));

    if (hasTxnOption()) {
      options.addOption("x", "txn", false, "use transactions");
      options.addOption(
          OptionBuilder.withLongOpt("batch-size")
              .withDescription("transaction batch size (default: 1)")
              .hasArg(true)
              .withArgName("BATCH-SIZE")
              .create('B'));
      options.addOption(
          OptionBuilder.withLongOpt("rollback-ratio")
              .withDescription("rollback ratio - must be between 0 and 1 (default: 0)")
              .hasArg(true)
              .withArgName("RATIO")
              .create('R'));
    }

    if (hasLinkDurableOption()) {
      options.addOption("d", "durable-link", false, "use a durable link");
    }

    if (hasStdInOption())
      options.addOption("i", "stdin", false, "read messages from stdin (one message per line)");

    options.addOption(
        OptionBuilder.withLongOpt("trace")
            .withDescription("trace logging specified categories: RAW, FRM")
            .hasArg(true)
            .withArgName("TRACE")
            .create('t'));
    if (hasSizeOption())
      options.addOption(
          OptionBuilder.withLongOpt("message-size")
              .withDescription("size to pad outgoing messages to")
              .hasArg(true)
              .withArgName("SIZE")
              .create('z'));

    if (hasResponseQueueOption())
      options.addOption(
          OptionBuilder.withLongOpt("response-queue")
              .withDescription("response queue to reply to")
              .hasArg(true)
              .withArgName("RESPONSE_QUEUE")
              .create('r'));

    if (hasLinkNameOption()) {
      options.addOption(
          OptionBuilder.withLongOpt("link")
              .withDescription("link name")
              .hasArg(true)
              .withArgName("LINK")
              .create('l'));
    }

    if (hasWindowSizeOption()) {
      options.addOption(
          OptionBuilder.withLongOpt("window-size")
              .withDescription("credit window size")
              .hasArg(true)
              .withArgName("WINDOW-SIZE")
              .create('W'));
    }

    CommandLine cmdLine = null;
    try {
      cmdLine = cmdLineParse.parse(options, args);

    } catch (ParseException e) {
      printUsage(options);
      System.exit(-1);
    }

    if (cmdLine.hasOption('h') || cmdLine.getArgList().isEmpty()) {
      printUsage(options);
      System.exit(0);
    }
    _host = cmdLine.getOptionValue('H', "0.0.0.0");
    _remoteHost = cmdLine.getOptionValue('O', null);
    String portStr = cmdLine.getOptionValue('p', "5672");
    String countStr = cmdLine.getOptionValue('c', "1");

    _useSSL = cmdLine.hasOption('S');

    if (hasWindowSizeOption()) {
      String windowSizeStr = cmdLine.getOptionValue('W', "100");
      _windowSize = Integer.parseInt(windowSizeStr);
    }

    if (hasSubjectOption()) {
      _subject = cmdLine.getOptionValue('s');
    }

    if (cmdLine.hasOption('u')) {
      _username = cmdLine.getOptionValue('u');
    }

    if (cmdLine.hasOption('w')) {
      _password = cmdLine.getOptionValue('w');
    }

    if (cmdLine.hasOption('F')) {
      _filter = cmdLine.getOptionValue('F');
    }

    _port = Integer.parseInt(portStr);

    _containerName = cmdLine.getOptionValue('C');

    if (hasBlockOption()) _block = cmdLine.hasOption('b');

    if (hasLinkNameOption()) _linkName = cmdLine.getOptionValue('l');

    if (hasLinkDurableOption()) _durableLink = cmdLine.hasOption('d');

    if (hasCountOption()) _count = Integer.parseInt(countStr);

    if (hasStdInOption()) _useStdIn = cmdLine.hasOption('i');

    if (hasSingleLinkPerConnectionMode()) _useMultipleConnections = cmdLine.hasOption('Z');

    if (hasTxnOption()) {
      _useTran = cmdLine.hasOption('x');
      _batchSize = Integer.parseInt(cmdLine.getOptionValue('B', "1"));
      _rollbackRatio = Double.parseDouble(cmdLine.getOptionValue('R', "0"));
    }

    if (hasModeOption()) {
      _mode = AcknowledgeMode.ALO;

      if (cmdLine.hasOption('k')) {
        _mode = AcknowledgeMode.valueOf(cmdLine.getOptionValue('k'));
      }
    }

    if (hasResponseQueueOption()) {
      _responseQueue = cmdLine.getOptionValue('r');
    }

    _frameSize = Integer.parseInt(cmdLine.getOptionValue('f', "65536"));

    if (hasSizeOption()) {
      _messageSize = Integer.parseInt(cmdLine.getOptionValue('z', "-1"));
    }

    String categoriesList = cmdLine.getOptionValue('t');
    String[] categories = categoriesList == null ? new String[0] : categoriesList.split("[, ]");
    for (String cat : categories) {
      if (cat.equalsIgnoreCase("FRM")) {
        FRAME_LOGGER.setLevel(Level.FINE);
        Formatter formatter =
            new Formatter() {
              @Override
              public String format(final LogRecord record) {
                return "[" + record.getMillis() + " FRM]\t" + record.getMessage() + "\n";
              }
            };
        for (Handler handler : FRAME_LOGGER.getHandlers()) {
          FRAME_LOGGER.removeHandler(handler);
        }
        Handler handler = new ConsoleHandler();
        handler.setLevel(Level.FINE);
        handler.setFormatter(formatter);
        FRAME_LOGGER.addHandler(handler);
      } else if (cat.equalsIgnoreCase("RAW")) {
        RAW_LOGGER.setLevel(Level.FINE);
        Formatter formatter =
            new Formatter() {
              @Override
              public String format(final LogRecord record) {
                return "[" + record.getMillis() + " RAW]\t" + record.getMessage() + "\n";
              }
            };
        for (Handler handler : RAW_LOGGER.getHandlers()) {
          RAW_LOGGER.removeHandler(handler);
        }
        Handler handler = new ConsoleHandler();
        handler.setLevel(Level.FINE);
        handler.setFormatter(formatter);
        RAW_LOGGER.addHandler(handler);
      }
    }

    _args = cmdLine.getArgs();
  }
Beispiel #3
0
  public void parse() {
    PerfPrediction predict = new PerfPrediction();
    CommandLineParser parser = new DefaultParser();
    CommandLine cmd = null;
    try {
      cmd = parser.parse(options, args);

      if (cmd.hasOption("h")) {
        help();
      }

      if (cmd.getOptions().length == 0) {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
          if (reader.ready()) {
            predict.add(reader, "");
            predict.printFixedValues();
          } else {
            help();
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
        return;
      }

      if (cmd.hasOption("cs") && cmd.getOptionValue("cs").equals("sqlite")) {
        if (cmd.hasOption("f")) {
          File location = new File(cmd.getOptionValue("f"));
          if (location.isDirectory()) {
            setSQLitePredictionScenarioNo(location);
            if (cmd.hasOption("im")) {
              if (isValidMode(cmd.getOptionValue("im"))) {
                if (cmd.hasOption("pm")) {
                  if (isValidMode(cmd.getOptionValue("pm"))) {
                    this.INPUT_MODE = cmd.getOptionValue("im");
                    this.PREDICT_MODE = cmd.getOptionValue("pm");
                    try {
                      predict.addPrediction(location, this.INPUT_MODE);
                    } catch (Exception e) {
                      e.printStackTrace();
                    }
                    predict.predict(this.PREDICT_MODE, getSQLiteDir(), location);

                  } else {
                    log.log(
                        Level.SEVERE, "invalid mode for option '-pm " + validModesToString() + "'");
                  }
                } else {
                  log.log(
                      Level.SEVERE, "missing prediction mode '-pm " + validModesToString() + "'");
                }
              } else {
                log.log(Level.SEVERE, "invalid mode for option '-im " + validModesToString() + "'");
              }
            } else {
              log.log(Level.SEVERE, "missing input mode '-im " + validModesToString() + "'");
            }

          } else {
            log.log(
                Level.SEVERE,
                "'-f <location>' does not point to a folder",
                cmd.getOptionValue("f"));
          }
        } else {
          log.log(Level.SEVERE, "Use option '-f <location>'", cmd.getOptionValue("f"));
        }
      }
      if (cmd.hasOption("rc")) {
        GenerateRandomConfig.generateConfigs(cmd.getOptionValue("rc"));
      }
      if (cmd.hasOption("fo")) {
        try (BufferedReader reader = new BufferedReader(new FileReader(cmd.getOptionValue("fo")))) {
          predict.add(reader, "");
          predict.printFixedValues();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      if (cmd.hasOption("md")) {
        Accumulator.enableMedian();
      }
      if (cmd.hasOption("acc")) {
        Accumulator.start(new File(cmd.getOptionValue("acc")));
      }

    } catch (ParseException e) {
      log.log(Level.SEVERE, "Failed to parse comand line properties", e);
      help();
    }
  }