Java 类org.apache.commons.cli.Option 实例源码

public static void main(String[] args) throws ParseException {
  Options options = new Options();
  Option nameOption = new Option("n", true, "Name to resolve");
  nameOption.setRequired(true);
  options.addOption(nameOption);
  CommandLineParser parser = new BasicParser();
  CommandLine cmd = parser.parse(options, args);

  BasicConfigurator.configure();
  Logger.getRootLogger().setLevel(Level.DEBUG);
  PodCIDRToNodeMapping plugin = new PodCIDRToNodeMapping();
  Configuration conf = new Configuration();
  plugin.setConf(conf);

  String nameToResolve = cmd.getOptionValue(nameOption.getOpt());
  List<String> networkPathDirs = plugin.resolve(Lists.newArrayList(nameToResolve));
  log.info("Resolved " + nameToResolve + " to " + networkPathDirs);
}

/**
 * Initialize the command line interface.
 */
private static void initCli() {
    options = new Options();
    options.addOption("b", BYGONE, false, "Signals a historical conversion");
    options.addOption("v", SKIP_VALIDATION, false, "Skip validations");
    options.addOption("d", SKIP_DEFAULTS, false,"Skip defaulted transformations");
    options.addOption("h", HELP, false,"This help message");

    Option templateScope = Option.builder("t")
            .longOpt(TEMPLATE_SCOPE)
            .argName("scope1,scope2,...")
            .hasArg()
            .desc("Comma delimited scope values to use for context. Valid values: "
                    + Arrays.toString(QrdaScope.getNames()))
            .build();
    options.addOption(templateScope);

    formatter = new HelpFormatter();
}

private static Options getOptions() {
  Options options = new Options();
  options.addOption("b", "bind", true,
      "Address to bind the Thrift server to. [default: 0.0.0.0]");
  options.addOption("p", "port", true, "Port to bind to [default: " + DEFAULT_LISTEN_PORT + "]");
  options.addOption("f", "framed", false, "Use framed transport");
  options.addOption("c", "compact", false, "Use the compact protocol");
  options.addOption("w", "workers", true, "How many worker threads to use.");
  options.addOption("h", "help", false, "Print help information");
  options.addOption(null, "infoport", true, "Port for web UI");
  options.addOption("t", READ_TIMEOUT_OPTION, true,
    "Amount of time in milliseconds before a server thread will timeout " +
    "waiting for client to send data on a connected socket. Currently, " +
    "only applies to TBoundedThreadPoolServer");
  OptionGroup servers = new OptionGroup();
  servers.addOption(
      new Option("nonblocking", false, "Use the TNonblockingServer. This implies the framed transport."));
  servers.addOption(new Option("hsha", false, "Use the THsHaServer. This implies the framed transport."));
  servers.addOption(new Option("threadpool", false, "Use the TThreadPoolServer. This is the default."));
  options.addOptionGroup(servers);
  return options;
}

public static Options buildOptions() {
    Options options = new Options();
    optionLCI.setArgs(1);
    optionLCI.setArgs(1);
    optionUCI.setArgs(1);
    optionUCO.setArgs(1);
    optionK.setArgs(Option.UNLIMITED_VALUES);
    optionK.setRequired(true);
    options.addOption(optionLCI);
    options.addOption(optionLCO);
    options.addOption(optionUCI);
    options.addOption(optionUCO);
    options.addOption(optionD);
    options.addOption(optionR);
    options.addOption(optionK);
    options.addOption(optionS);
    return options;
}

/**
 * Small helper for creating some of the long parameter settings we frequently
 * use here.
 *
 * @param optName       name of the parameter/option
 * @param description   description for the help text
 * @param isRequired    whether this parameter is strictly required
 * @param unlimitedArgs whether it supports multiple arguments, default is on argument
 */
public static Option createOption(String optName, String description,
    boolean isRequired, boolean unlimitedArgs) {

  Option.Builder builder = Option.builder()
      .longOpt(optName)
      .hasArg()
      .valueSeparator(',')
      .required(isRequired)
      .desc(description);

  if (unlimitedArgs) {
    builder.hasArgs();
  }

  return builder.build();
}

/**
 *  Usage:  ReplicaStatsRetriever  \
 *             -brokerstatszk    datazk001:2181/data07    \
 *             -brokerstatstopic brokerstats              \
 *             -clusterzk  m10nzk001:2181,...,m10nzk007:2181/m10n07 \
 *             -seconds 43200
 */
private static CommandLine parseCommandLine(String[] args) {
  Option config = new Option(CONFIG, true, "operator config");
  Option brokerStatsZookeeper =
      new Option(BROKERSTATS_ZOOKEEPER, true, "zookeeper for brokerstats topic");
  Option brokerStatsTopic = new Option(BROKERSTATS_TOPIC, true, "topic for brokerstats");
  Option clusterZookeeper = new Option(CLUSTER_ZOOKEEPER, true, "cluster zookeeper");
  Option seconds = new Option(SECONDS, true, "examined time window in seconds");
  options.addOption(config).addOption(brokerStatsZookeeper).addOption(brokerStatsTopic)
      .addOption(clusterZookeeper).addOption(seconds);

  if (args.length < 6) {
    printUsageAndExit();
  }

  CommandLineParser parser = new DefaultParser();
  CommandLine cmd = null;
  try {
    cmd = parser.parse(options, args);
  } catch (ParseException | NumberFormatException e) {
    printUsageAndExit();
  }
  return cmd;
}

/**
 *  Usage:  BrokerStatsRetriever  \
 *             --brokerstatszk    datazk001:2181/data07    \
 *             --brokerstatstopic brokerstats              \
 *             --broker  kafkabroker001
 */
private static CommandLine parseCommandLine(String[] args) {
  Option config = new Option(CONFIG, true, "operator config");
  Option brokerStatsZookeeper =
      new Option(BROKERSTATS_ZOOKEEPER, true, "zookeeper for brokerstats topic");
  Option brokerStatsTopic = new Option(BROKERSTATS_TOPIC, true, "topic for brokerstats");
  Option broker = new Option(BROKERNAME, true, "broker name");
  options.addOption(config).addOption(brokerStatsZookeeper).addOption(brokerStatsTopic)
      .addOption(broker);

  if (args.length < 6) {
    printUsageAndExit();
  }

  CommandLineParser parser = new DefaultParser();
  CommandLine cmd = null;
  try {
    cmd = parser.parse(options, args);
  } catch (ParseException | NumberFormatException e) {
    printUsageAndExit();
  }
  return cmd;
}

private static CommandLine parseCommandLine(String[] args) {

    Option host = new Option(BROKER_NAME, true, "kafka broker");
    Option jmxPort = new Option(JMX_PORT, true, "kafka jmx port number");
    jmxPort.setArgName("kafka jmx port number");

    Option metric = new Option(METRICS_NAME, true, "jmx metric name");

    options.addOption(jmxPort).addOption(host).addOption(metric);

    if (args.length < 4) {
      printUsageAndExit();
    }
    CommandLineParser parser = new DefaultParser();
    CommandLine cmd = null;
    try {
      cmd = parser.parse(options, args);
    } catch (ParseException | NumberFormatException e) {
      printUsageAndExit();
    }
    return cmd;
  }

public static Properties commandLine2Properties(final CommandLine commandLine) {
    Properties properties = new Properties();
    Option[] opts = commandLine.getOptions();

    if (opts != null) {
        for (Option opt : opts) {
            String name = opt.getLongOpt();
            String value = commandLine.getOptionValue(name);
            if (value != null) {
                properties.setProperty(name, value);
            }
        }
    }

    return properties;
}

@Override
public Options buildCommandlineOptions(Options options) {
    Option opt = new Option("b", "brokerName", true, "broker name");
    opt.setRequired(true);
    options.addOption(opt);
    return options;
}

public static Properties commandLine2Properties(final CommandLine commandLine) {
    Properties properties = new Properties();
    Option[] opts = commandLine.getOptions();

    if (opts != null) {
        for (Option opt : opts) {
            String name = opt.getLongOpt();
            String value = commandLine.getOptionValue(name);
            if (value != null) {
                properties.setProperty(name, value);
            }
        }
    }

    return properties;
}

/**
 * Create the CLI Options
 * 
 * @return the CLI Options
 * @throws IllegalArgumentException
 */
private static Options createOptions() throws IllegalArgumentException {
    Options options = new Options();

    // add an option
    options.addOption("help", false, "print this message");

    options.addOption("start", false, "start the SQL Web server");

    options.addOption("stop", false, "stop the SQL Web server");

    options.addOption("version", false, "print version");

    String propertiesOptionMesssage = getPropertiesOptionMessage();

    @SuppressWarnings("static-access")
    Option propertiesOption = OptionBuilder.withArgName("file").hasArg().withDescription(propertiesOptionMesssage)
            .create("properties");

    @SuppressWarnings("static-access")
    Option hostOption = OptionBuilder.withArgName("hostname").hasArg().withDescription("hostname of the Web server")
            .create("host");

    @SuppressWarnings("static-access")
    Option portOption = OptionBuilder.withArgName("port number").hasArg()
            .withDescription("port number of the Web server. Defaults to " + WebServerApi.DEFAULT_PORT)
            .create("port");

    options.addOption(propertiesOption);
    options.addOption(hostOption);
    options.addOption(portOption);

    return options;
}

/**
 * Construct and provide Posix-compatible Options.
 * 
 * @return Options expected from command-line of Posix form.
 */
private static Options constructPosixOptions() {
    final Options posixOptions = new Options();
    posixOptions.addOption(
            Option.builder(VERBOSE_OPTION).desc("Enable verbose mode").hasArg(false).required(false).build());
    posixOptions.addOption(
            Option.builder(PASSWORD_OPTION).desc("User defined password").hasArg(true).required(false).build());
    posixOptions.addOption(Option.builder(CIPHERED_FILE_OPTION)
            .desc("Input ciphered file (or directory) to decipher").hasArg(true).required(true).build());
    posixOptions.addOption(Option.builder(PLAIN_FILE_OPTION).desc("Output plain file (or directory)").hasArg(true)
            .required(true).build());
    posixOptions.addOption(
            Option.builder(RECURSIVE_OPTION).desc("Enable recursive mode (WARNING : MAY TAKE A LONG TIME !)")
                    .hasArg(false).required(false).build());

    return posixOptions;
}

private static String getCommandName(String[] args) throws ParseException {

        Options opts = new Options();
        asList(CMOptions.HELP, CMOptions.VERSION, CMOptions.HOST, CMOptions.USER, CMOptions.PASSWORD).stream().map(
           new Function<Option, Option>() {

              @Override
              public Option apply(Option o) {
                Option c = CMOptions.clone(o);
                c.setRequired(false);
                return c;
              }
          }).forEach(o -> opts.addOption(o));

          CommandLine parser = new DefaultParser().parse(opts, args, true);
          if(parser.getArgs().length == 0) {
              throw new CMCommandLineException(format("Canmnot extract command name from arguments: '%s'.",
                        getArgsLogString(args)));
          }
          String commandName = parser.getArgs()[0];
          logger.debug(format("Command name '%s' extracted from command line '%s'.", commandName, getArgsLogString(args)));
          return commandName;
    }

public void printPrelude(Option task) {
    String applicationName = Settings.getString(SettingCodes.APPLICATION_NAME, Bundle.SETTINGS, null);
    String applicationVersion = Settings.getString(SettingCodes.APPLICATION_VERSION, Bundle.SETTINGS, null);
    String instanceName = Settings.getInstanceName();
    if (!CommonUtil.isEmptyString(applicationName)) {
        println(applicationName);
    }
    if (!CommonUtil.isEmptyString(applicationVersion)) {
        println("version: " + applicationVersion);
    }
    if (!CommonUtil.isEmptyString(instanceName)) {
        println("instance: " + instanceName);
    }
    println("jvm: " + System.getProperty("java.version"));
    if (task != null && !CommonUtil.isEmptyString(task.getDescription())) {
        println(task.getDescription());
    }
}

/**
 *  Usage:  KafkaWriter  \
 *             --zookeeper datazk001:2181/testk10 --topic kafka_test    \
 *             --num_messages 100
 */
private static CommandLine parseCommandLine(String[] args) {
  Option zookeeper = new Option(ZOOKEEPER, true, "zookeeper connection string");
  Option topic = new Option(TOPIC, true, "topic that KafkaWriter writes to");
  Option num_messages = new Option(NUM_MESSAGES, true, "num of messags that writes to kafka");
  options.addOption(zookeeper).addOption(topic).addOption(num_messages);

  if (args.length < 6) {
    printUsageAndExit();
  }

  CommandLineParser parser = new DefaultParser();
  CommandLine cmd = null;
  try {
    cmd = parser.parse(options, args);
  } catch (ParseException | NumberFormatException e) {
    printUsageAndExit();
  }
  return cmd;
}

/**
 * "Definition" stage of command-line parsing with Apache Commons CLI.
 * @return Definition of command-line options.
 */
private static Options generateOptions()
{
   final Option verboseOption = Option.builder("v")
      .required(false)
      .hasArg(false)
      .longOpt(VERBOSE_OPTION)
      .desc("Print status with verbosity.")
      .build();
   final Option fileOption = Option.builder("f")
      .required()
      .longOpt(FILE_OPTION)
      .hasArg()
      .desc("File to be processed.")
      .build();
   final Options options = new Options();
   options.addOption(verboseOption);
   options.addOption(fileOption);
   return options;
}

@Override
public Options buildCommandlineOptions(Options options) {
    Option opt = new Option("g", "groupName", true, "consumer group name");
    opt.setRequired(false);
    options.addOption(opt);

    return options;
}

/**
 *  Usage:  ClusterLoadBalancer  \
 *             -brokerstatszk    zookeeper001:2181/cluster1  \
 *             -brokerstatstopic brokerstats                 \
 *             -clusterzk  zookeeper001:2181,...,zookeeper007:2181/cluster2 \
 *             -brokerids  2048,2051  -seconds  43200
 *             -onlyone
 */
private static CommandLine parseCommandLine(String[] args) {
  Option brokerStatsZookeeper =
      new Option(BROKERSTATS_ZOOKEEPER, true, "zookeeper for brokerstats topic");
  Option config = new Option(CONFIG, true, "doctorkafka config");
  Option brokerStatsTopic = new Option(BROKERSTATS_TOPIC, true, "topic for brokerstats");
  Option clusterZookeeper = new Option(CLUSTER_ZOOKEEPER, true, "cluster zookeeper");
  Option seconds = new Option(SECONDS, true, "examined time window in seconds");
  Option onlyOne = new Option(ONLY_ONE, false, "only balance broker that has the heaviest load");
  options.addOption(config).addOption(brokerStatsZookeeper).addOption(brokerStatsTopic)
      .addOption(clusterZookeeper).addOption(seconds).addOption(onlyOne);

  if (args.length < 6) {
    printUsageAndExit();
  }

  CommandLineParser parser = new DefaultParser();
  CommandLine cmd = null;
  try {
    cmd = parser.parse(options, args);
  } catch (ParseException | NumberFormatException e) {
    printUsageAndExit();
  }
  return cmd;
}

@Override
protected Options getOptions() {
  Options options = super.getOptions();
  options.addOption(Option.builder("n")
    .desc("Script name. The latest version of the script with the " +
          "given name will be started.  The name has to identify one " +
          "script by matching the last part so you don't have to type " +
          "the full name. It's required to provide either n or v.")
    .hasArg()
    .build());
  options.addOption(Option.builder("v")
    .desc("Script version id. This identifies the specific version of a script " +
          "to start. It's required to provide either n or v.")
    .hasArg()
    .build());
  options.addOption(Option.builder("p")
    .desc("Input property <propertyName>:<propertyValue>. " +
          "The property will be added to the JSON input object.")
    .numberOfArgs(2)
    .valueSeparator(':')
    .build());
  return options;
}

@Override
protected Options getOptions() {
  Options options = super.getOptions();
  options.addOption(Option.builder("seid")
    .desc("Script execution id. This identifies the script execution. " +
          "Required.")
    .required()
    .hasArg()
    .build());
  options.addOption(Option.builder("eid")
    .desc("Execution id. This identifies the position inside the script " +
          "execution that corresponds to the service function invocation. " +
          "Required.")
    .required()
    .hasArg()
    .build());
  options.addOption(Option.builder("r")
    .desc("Result property <propertyName>:<propertyValue>. " +
          "The property will be added as a field to the service function's " +
          "return value.")
    .numberOfArgs(2)
    .valueSeparator(':')
    .build());
  return options;
}

private static Options getOptions() {
    Options options = new Options();
    options.addOption(
            Option.builder("in").longOpt(PARAMETER_INPUT_FILE).argName("input file").hasArg().desc("Input file. Can be a .rpx or .rpx").required().build());
    options.addOption(Option.builder("f").longOpt(PARAMETER_FUNCTION_FILTER).argName("function name")
            .desc("Filter for the function. The function need to contain this string if it's provided").hasArg().desc("").build());
    options.addOption(Option.builder("a").longOpt(PARAMETER_OUTPUT_ADDRESS).desc("Enables the output of the function address").build());
    options.addOption(Option.builder("d").longOpt(PARAMETER_DEMANGLE)
            .desc("Enables the function name demangling. May not work for every function. Requires " + DEMANGLER_FILE_PATH).build());
    options.addOption(Option.builder("out").longOpt(PARAMETER_OUTFILE).hasArg().desc("Where the result will be stored.").build());

    options.addOption("help", false, "Shows this text");

    return options;
}

/**
 * Builds the option `silent`.
 * @return the option.
 */
private Option optSilent() {
  return Option.builder("s")
      .longOpt("silent")
      .desc(DESCRIPTION_SILENT)
      .required(false)
      .hasArg(false)
      .build();
}

@Override
public Command getCommand() {
    return new Command() {
        @Override
        public String getName() {
            return "afs";
        }

        @Override
        public String getTheme() {
            return "Application file system";
        }

        @Override
        public String getDescription() {
            return "application file system command line tool";
        }

        @Override
        public Options getOptions() {
            Options options = new Options();
            OptionGroup optionGroup = new OptionGroup();
            optionGroup.addOption(Option.builder()
                    .longOpt(LS)
                    .desc("list files")
                    .hasArg()
                    .optionalArg(true)
                    .argName("PATH")
                    .build());
            options.addOptionGroup(optionGroup);
            return options;
        }

        @Override
        public String getUsageFooter() {
            return null;
        }
    };
}

@Override
public Options getOptions() {
    Options options = new Options();
    options.addOption(Option.builder()
            .longOpt(FILE)
            .desc("the script file")
            .hasArg()
            .required()
            .argName("FILE")
            .build());
    return options;
}

@Override
public Options getOptions() {
    Options options = new Options();
    options.addOption(Option.builder().longOpt(CASE_FILE)
            .desc("case file path")
            .hasArg()
            .argName("FILE")
            .required()
            .build());
    options.addOption(Option.builder().longOpt(OUTPUT_FOLDER)
            .desc("output folder path")
            .hasArg()
            .argName("FOLDER")
            .required()
            .build());
    options.addOption(Option.builder().longOpt(LOAD_FLOW)
            .desc("run loadflow")
            .build());
    options.addOption(Option.builder().longOpt(VERBOSE)
            .desc("verbose output")
            .build());
    options.addOption(Option.builder().longOpt(OUTPUT_FORMAT)
            .desc("output format " + Arrays.toString(ValidationOutputWriter.values()))
            .hasArg()
            .argName("VALIDATION_WRITER")
            .build());
    options.addOption(Option.builder().longOpt(TYPES)
            .desc("validation types " + Arrays.toString(ValidationType.values()) + " to run, all of them if the option if not specified")
            .hasArg()
            .argName("VALIDATION_TYPE,VALIDATION_TYPE,...")
            .build());
    return options;
}

@Override
public Options buildCommandlineOptions(Options options) {
    Option opt = new Option("b", "brokerName", true, "broker name");
    opt.setRequired(true);
    options.addOption(opt);
    return options;
}

@Override
public Command getCommand() {
    return new Command() {
        @Override
        public String getName() {
            return "tool1";
        }

        @Override
        public String getTheme() {
            return "theme1";
        }

        @Override
        public String getDescription() {
            return "test tool1";
        }

        @Override
        public Options getOptions() {
            Options options = new Options();
            options.addOption(Option.builder()
                    .longOpt("option1")
                    .desc("this is option 1")
                    .hasArg()
                    .argName("FILE")
                    .required()
                    .build());
            return options;
        }

        @Override
        public String getUsageFooter() {
            return "footer1";
        }
    };
}

public static Options createMpiOptions() {
    Options options = new Options();
    options.addOption(Option.builder()
            .longOpt(TMP_DIR)
            .desc("local temporary directory")
            .hasArg()
            .argName("dir")
            .build());
    options.addOption(Option.builder()
            .longOpt(STATISTICS_DB_DIR)
            .desc("statistics db directory")
            .hasArg()
            .argName("dir")
            .build());
    options.addOption(Option.builder()
            .longOpt(STATISTICS_DB_NAME)
            .desc("statistics db name")
            .hasArg()
            .argName("name")
            .build());
    options.addOption(Option.builder()
            .longOpt(CORES)
            .desc("number of cores per rank")
            .hasArg()
            .required()
            .argName("n")
            .build());
    options.addOption(Option.builder()
            .longOpt(VERBOSE)
            .desc("verbose mode")
            .build());
    options.addOption(Option.builder()
            .longOpt(STDOUT_ARCHIVE)
            .desc("tasks standard output archive")
            .hasArg()
            .argName("file")
            .build());
    return options;
}

/**
 * Constructs the singleton of {@link BaseOptions}.
 */
private BaseOptions() {
  Option version = this.optVersion();
  Option help = this.optHelp();
  Option silent = this.optSilent();
  Option trace = this.optTrace();
  Option config = this.optConfig();

  super.addOption(version);
  super.addOption(help);
  super.addOption(silent);
  super.addOption(trace);
  super.addOption(config);
}

/**
 * Builds the option `trace`.
 * @return the option.
 */
private Option optTrace() {
  return Option.builder("t")
      .longOpt("trace")
      .desc(DESCRIPTION_TRACE)
      .required(false)
      .hasArg(false)
      .build();
}

@SuppressWarnings("unchecked")
public int rm(String[] args) {
  Option recursive = OptionBuilder.withArgName("recursive")
                                  .withDescription("delete recursively")
                                  .create("r");

  Options rmOption = new Options();
  rmOption.addOption(recursive);

  boolean recursiveOpt = false;

  CommandLineParser parser = new GnuParser();
  try {
    CommandLine line = parser.parse(rmOption, args);

    List<String> argsList = line.getArgList();
    if (argsList.size() != 2) {
      return usageError("RM requires exactly one path argument", RM_USAGE);
    }
    if (!validatePath(argsList.get(1))) {
      return -1;
    }

    try {
      if (line.hasOption("r")) {
        recursiveOpt = true;
      }

      registry.delete(argsList.get(1), recursiveOpt);
      return 0;
    } catch (Exception e) {
      syserr.println(analyzeException("rm", e, argsList));
    }
    return -1;
  } catch (ParseException exp) {
    return usageError("Invalid syntax " + exp.toString(), RM_USAGE);
  }
}

@SuppressWarnings("static-access")

public CLIParserBenchmarker() {
    Options options = new Options();
    Option inputDirectory = OptionBuilder.withArgName("input")
            .hasArg()
            .withDescription("Benchmark files directory.")
            .create("input");
    Option miner = OptionBuilder.withArgName("miner")
            .hasArg()
            .withDescription("Miner: tane, fastfds, fdiscminer.")
            .create("miner");
    Option delimiter = OptionBuilder.withArgName("delimiter")
            .hasArg()
            .withDescription("Delimiter of input files.")
            .create("delimiter");
    Option xmxForMiner = OptionBuilder.withArgName("xmx")
            .hasArg()
            .withDescription("Maximum heap space for miner.")
            .create("xmx");
    Option timeout = OptionBuilder.withArgName("timeout")
            .hasArg()
            .withDescription("Maximum calculation time for miner.")
            .create("timeout");

    Option allFiles = new Option("all", false, "Use all files in directory.");

    options.addOption(inputDirectory);
    options.addOption(miner);
    options.addOption(delimiter);
    options.addOption(xmxForMiner);
    options.addOption(timeout);
    options.addOption(allFiles);

    this.setOptions(options); 
}

public THashMap<String, String> parse(String[] input) {
    THashMap<String, String> result = new THashMap<>();
    try {
        CommandLine cmdLine = this.parse(this.getOptions(), input);
        for (Option option : cmdLine.getOptions()) {
            result.put(option.getOpt(), option.getValue());
        }
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return result;
}

@SuppressWarnings("static-access")

public CLIParserMiner() {
    Options options = new Options();
    Option inputFileName = OptionBuilder.withArgName("file")
            .hasArg()
            .withDescription("Input file name.")
            .create("file");
    Option inputDirectory = OptionBuilder.withArgName("input")
            .hasArg()
            .withDescription("Column files directory.")
            .create("input");
    Option resultFile = OptionBuilder.withArgName("result")
            .hasArg()
            .withDescription("Result file.")
            .create("result");
    Option numberOfColumns = OptionBuilder.withArgName("columns")
            .hasArg()
            .withDescription("Number of columns.")
            .create("columns");
    Option numberOfRows = OptionBuilder.withArgName("rows")
            .hasArg()
            .withDescription("Number of rows.")
            .create("rows");

    options.addOption(inputFileName);
    options.addOption(inputDirectory);
    options.addOption(resultFile);
    options.addOption(numberOfColumns);
    options.addOption(numberOfRows);

    this.setOptions(options); 
}

static OptionGroup createOptionGroup() {
  OptionGroup group = new OptionGroup();
  for (ImplType t : values()) {
    group.addOption(new Option(t.option, t.getDescription()));
  }
  return group;
}

protected void parseCommandLine(String[] args)
    throws DaemonInitException, ConfigurationException, BiremeException {
  Option help = new Option("help", "print this message");
  Option configFile =
      Option.builder("config_file").hasArg().argName("file").desc("config file location").build();

  Options opts = new Options();
  opts.addOption(help);
  opts.addOption(configFile);
  CommandLine cmd = null;
  CommandLineParser parser = new DefaultParser();

  try {
    cmd = parser.parse(opts, args);

    if (cmd.hasOption("help")) {
      throw new ParseException("print help message");
    }
  } catch (ParseException e) {
    HelpFormatter formatter = new HelpFormatter();
    StringWriter out = new StringWriter();
    PrintWriter writer = new PrintWriter(out);
    formatter.printHelp(writer, formatter.getWidth(), "Bireme", null, opts,
        formatter.getLeftPadding(), formatter.getDescPadding(), null, true);
    writer.flush();
    String result = out.toString();
    throw new DaemonInitException(result);
  }

  String config = cmd.getOptionValue("config_file", DEFAULT_CONFIG_FILE);

  cxt = new Context(new Config(config));
}

/**
 * Gets the cmd options.
 *
 * @return the cmd options
 */
private static Options getCmdOptions() {
    final Options options = new Options();

    options.addOption("h", "help", false, "show help");

    final Option algorithm = Option.builder(ALG_OPTION).argName("algorithm_name").hasArg()
            .desc("the metarecsys algorithm to use (borda, condorcet, copeland, combANZ, combSum, combMNZ)")
            .longOpt("algorithm").required().build();
    options.addOption(algorithm);

    final Option runs = Option.builder(RUN_OPTION).argName("folder").hasArg()
            .desc("path to the runs folder").longOpt("runs").required().build();
    options.addOption(runs);

    final Option output = Option.builder(OUT_OPTION).argName("folder").hasArg()
            .desc("path to the output folder").longOpt("output").required().build();
    options.addOption(output);

    final Option norm = Option.builder(NORM_OPTION).argName("norm_name").hasArg()
            .desc("the normalisation technique to use (none, standard, sum, zmuv, zmuv1, zmuv2)")
            .longOpt("normalisation").required().build();
    options.addOption(norm);

    final Option max = Option.builder(MAX_OPTION).argName("num").hasArg()
            .desc("maximum number of recommended items per user (100 by default)")
            .longOpt("max_rank").type(Integer.class).build();
    options.addOption(max);

    return options;
}

private static Option makeOption(String shortName, String longName, String description, String argName) {
  assert longName != null;

  Option option = new Option(shortName, longName, argName != null, description);

  if (argName != null) {
    option.setValueSeparator('=');
    option.setArgName(argName);
  }

  return option;
}

public ArgumentParser() {
    final Option input =
            new Option(KEY_INPUT, longOptInput, true,
                    "read in this S3 URI to get inventory manifest files");
    final Option output =
            new Option(KEY_OUTPUT, longOptOutput, true,
                    "write new files back to this output S3 URI prefix");
    this.options = new Options();
    input.setRequired(true);
    this.options.addOption(input);
    output.setRequired(true);
    this.options.addOption(output);
    this.parser = new PosixParser();
}