Example usage for org.apache.commons.cli Option setArgs

List of usage examples for org.apache.commons.cli Option setArgs

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.cli.*
  5. Option
  6. setArgs

Introduction

In this page you can find the example usage for org.apache.commons.cli Option setArgs.

Prototype

public void setArgs(int num)

Source Link

Document

Sets the number of argument values this Option can take.

Usage

From source file:com.rabbitmq.examples.MulticastMain.java

private static Options getOptions() {
    Options options = new Options();
    options.addOption(new Option("?", "help", false, "show usage"));
    options.addOption(new Option("h", "uri", true, "AMQP URI"));
    options.addOption(new Option("t", "type", true, "exchange type"));
    options.addOption(new Option("e", "exchange", true, "exchange name"));
    options.addOption(new Option("u", "queue", true, "queue name"));
    options.addOption(new Option("i", "interval", true, "sampling interval"));
    options.addOption(new Option("r", "rate", true, "rate limit"));
    options.addOption(new Option("x", "producers", true, "producer count"));
    options.addOption(new Option("y", "consumers", true, "consumer count"));
    options.addOption(new Option("m", "ptxsize", true, "producer tx size"));
    options.addOption(new Option("n", "ctxsize", true, "consumer tx size"));
    options.addOption(new Option("c", "confirm", true, "max unconfirmed publishes"));
    options.addOption(new Option("a", "autoack", false, "auto ack"));
    options.addOption(new Option("q", "qos", true, "qos prefetch count"));
    options.addOption(new Option("s", "size", true, "message size"));
    options.addOption(new Option("z", "time", true, "time limit"));
    Option flag = new Option("f", "flag", true, "message flag");
    flag.setArgs(Option.UNLIMITED_VALUES);
    options.addOption(flag);//from  w ww  .j ava  2 s  .  co m
    options.addOption(new Option("M", "framemax", true, "frame max"));
    options.addOption(new Option("b", "heartbeat", true, "heartbeat interval"));
    return options;
}

From source file:com.linkedin.helix.mock.storage.DummyProcess.java

@SuppressWarnings("static-access")
synchronized private static Options constructCommandLineOptions() {
    Option helpOption = OptionBuilder.withLongOpt(help).withDescription("Prints command-line options info")
            .create();/*from   w ww .  j ava2 s .c  om*/

    Option clusterOption = OptionBuilder.withLongOpt(cluster).withDescription("Provide cluster name").create();
    clusterOption.setArgs(1);
    clusterOption.setRequired(true);
    clusterOption.setArgName("Cluster name (Required)");

    Option hostOption = OptionBuilder.withLongOpt(hostAddress).withDescription("Provide host name").create();
    hostOption.setArgs(1);
    hostOption.setRequired(true);
    hostOption.setArgName("Host name (Required)");

    Option portOption = OptionBuilder.withLongOpt(hostPort).withDescription("Provide host port").create();
    portOption.setArgs(1);
    portOption.setRequired(true);
    portOption.setArgName("Host port (Required)");

    Option cmTypeOption = OptionBuilder.withLongOpt(helixManagerType)
            .withDescription("Provide cluster manager type (e.g. 'zk', 'static-file', or 'dynamic-file'")
            .create();
    cmTypeOption.setArgs(1);
    cmTypeOption.setRequired(true);
    cmTypeOption.setArgName("Clsuter manager type (e.g. 'zk', 'static-file', or 'dynamic-file') (Required)");

    // add an option group including either --zkSvr or --clusterViewFile
    Option fileOption = OptionBuilder.withLongOpt(clusterViewFile)
            .withDescription("Provide a cluster-view file for static-file based cluster manager").create();
    fileOption.setArgs(1);
    fileOption.setRequired(true);
    fileOption.setArgName("Cluster-view file (Required for static-file based cluster manager)");

    Option zkServerOption = OptionBuilder.withLongOpt(zkServer).withDescription("Provide zookeeper address")
            .create();
    zkServerOption.setArgs(1);
    zkServerOption.setRequired(true);
    zkServerOption.setArgName("ZookeeperServerAddress(Required for zk-based cluster manager)");

    //    Option rootNsOption = OptionBuilder.withLongOpt(rootNamespace)
    //        .withDescription("Provide root namespace for dynamic-file based cluster manager").create();
    //    rootNsOption.setArgs(1);
    //    rootNsOption.setRequired(true);
    //    rootNsOption.setArgName("Root namespace (Required for dynamic-file based cluster manager)");

    Option transDelayOption = OptionBuilder.withLongOpt(transDelay).withDescription("Provide state trans delay")
            .create();
    transDelayOption.setArgs(1);
    transDelayOption.setRequired(false);
    transDelayOption.setArgName("Delay time in state transition, in MS");

    OptionGroup optionGroup = new OptionGroup();
    optionGroup.addOption(zkServerOption);
    optionGroup.addOption(fileOption);
    //    optionGroup.addOption(rootNsOption);

    Options options = new Options();
    options.addOption(helpOption);
    options.addOption(clusterOption);
    options.addOption(hostOption);
    options.addOption(portOption);
    options.addOption(transDelayOption);
    options.addOption(cmTypeOption);

    options.addOptionGroup(optionGroup);

    return options;
}

From source file:de.iew.imageread.Main.java

protected static Options setupOptions() {
    Options options = new Options();

    Option imageOutputDirOption = new Option("o", "outputDir", true,
            "The base directory to write the images to (Default: system temp directory)");
    imageOutputDirOption.setArgName("outputDir");

    Option imageFilenamePrefixOption = new Option("p", "filenamePrefix", true,
            "The basename/prefix for each image (Default: image-)");
    imageFilenamePrefixOption.setArgName("filenamePrefix");

    Option groupingOutputOption = new Option("g", "groupingOutput", true,
            "Grouping option for the images; valid values are ALL, GROUP_BY_DAY (Default: ALL)");
    groupingOutputOption.setArgName("groupingOutput");
    groupingOutputOption.setType(OUTPUT_OPTION.class);

    Option queryOption = new Option("q", "query", true,
            "Query filters for the mongo db queries; valid values for 'query' are FROM, TO and EXACT (Default: no specific query)");
    queryOption.setArgs(2);
    queryOption.setArgName("query=date");
    queryOption.setValueSeparator('=');

    Option databaseOption = new Option("md", "database", true, "The mongo db database (Default: test)");
    databaseOption.setArgName("database");

    Option mongodbHostOption = new Option("mh", "hostname", true,
            "The hostname of the mongo db instance (Default: localhost)");
    mongodbHostOption.setArgName("hostname");

    Option mongodbPortOption = new Option("mp", "port", true,
            "The port of the mongo db instance (Default: 27017)");
    mongodbPortOption.setArgName("port");
    mongodbPortOption.setType(Integer.TYPE);

    Option printHelpOption = new Option("h", "help", false, "Print help");

    options.addOption(imageOutputDirOption);
    options.addOption(imageFilenamePrefixOption);
    options.addOption(groupingOutputOption);
    options.addOption(queryOption);/*from   ww w .j a va 2 s .co  m*/
    options.addOption(databaseOption);
    options.addOption(mongodbHostOption);
    options.addOption(mongodbPortOption);

    options.addOption(printHelpOption);

    return options;
}

From source file:com.facebook.LinkBench.LinkBenchDriver.java

private static Options initializeOptions() {
    Options options = new Options();
    Option config = new Option("c", true, "Linkbench config file");
    config.setArgName("file");
    options.addOption(config);/*from  w  w w . ja  v a  2 s  .co m*/

    Option log = new Option("L", true, "Log to this file");
    log.setArgName("file");
    options.addOption(log);

    Option csvStats = new Option("csvstats", "csvstats", true, "CSV stats output");
    csvStats.setArgName("file");
    options.addOption(csvStats);

    Option csvStream = new Option("csvstream", "csvstream", true, "CSV streaming stats output");
    csvStream.setArgName("file");
    options.addOption(csvStream);

    options.addOption("l", false, "Execute loading stage of benchmark");
    options.addOption("r", false, "Execute request stage of benchmark");

    // Java-style properties to override config file
    // -Dkey=value
    Option property = new Option("D", "Override a config setting");
    property.setArgs(2);
    property.setArgName("property=value");
    property.setValueSeparator('=');
    options.addOption(property);

    return options;
}

From source file:fr.inria.atlanmod.dag.instantiator.Launcher.java

/**
 * Configures the program options/*ww w  . ja v  a 2s  .  c om*/
 *
 * @param options
 */
private static void configureOptions(Options options) {

    Option outDirOpt = OptionBuilder.create(OUTPUT_PATH);
    outDirOpt.setLongOpt(OUTPUT_PATH_LONG);
    outDirOpt.setArgName("neoEMF output uri");
    outDirOpt.setDescription("Output directory (defaults to working dir)");
    outDirOpt.setArgs(1);
    outDirOpt.setRequired(true);

    Option nModelsOpt = OptionBuilder.create(N_MODELS);
    nModelsOpt.setLongOpt(N_MODELS_LONG);
    nModelsOpt.setArgName("models");
    nModelsOpt.setDescription("Number of generated models (defaults to 1)");
    nModelsOpt.setType(Number.class);
    nModelsOpt.setArgs(1);

    Option sizeOption = OptionBuilder.create(SIZE);
    sizeOption.setLongOpt(SIZE_LONG);
    sizeOption.setArgName("size");
    sizeOption.setDescription(MessageFormat.format("Average models'' size (defaults to {0})",
            Launcher.DEFAULT_AVERAGE_MODEL_SIZE));
    sizeOption.setType(Number.class);
    sizeOption.setArgs(1);

    Option densityOption = OptionBuilder.create(VARIATION);
    densityOption.setLongOpt(VARIATION_LONG);
    densityOption.setArgName("proportion");
    densityOption.setDescription(MessageFormat
            .format("Variation ([0..1]) in the models'' size (defaults to {0})", Launcher.DEFAULT_DEVIATION));
    densityOption.setType(Number.class);
    densityOption.setArgs(1);

    Option propVariationOption = OptionBuilder.create(PROP_VARIATION);
    propVariationOption.setLongOpt(PROP_VARIATION_LONG);
    propVariationOption.setArgName("properties deviation");
    propVariationOption.setDescription(MessageFormat.format(
            "Variation ([0..1]) in the properties'' size (defaults to {0})", Launcher.DEFAULT_DEVIATION));
    propVariationOption.setType(Number.class);
    propVariationOption.setArgs(1);

    Option seedOption = OptionBuilder.create(SEED);
    seedOption.setLongOpt(SEED_LONG);
    seedOption.setArgName("seed");
    seedOption.setDescription("Seed number (random by default)");
    seedOption.setType(Number.class);
    seedOption.setArgs(1);

    Option valuesSizeOption = OptionBuilder.create(VALUES_SIZE);
    valuesSizeOption.setLongOpt(VALUES_SIZE_LONG);
    valuesSizeOption.setArgName("size");
    valuesSizeOption.setDescription(MessageFormat.format(
            "Average size for attributes with variable length (defaults to {0}). Actual sizes may vary +/- {1}%.",
            GenericMetamodelConfig.DEFAULT_AVERAGE_VALUES_LENGTH,
            GenericMetamodelConfig.DEFAULT_VALUES_DEVIATION * 100));
    valuesSizeOption.setType(Number.class);
    valuesSizeOption.setArgs(1);

    Option degreeOption = OptionBuilder.create(DEGREE);
    degreeOption.setLongOpt(DEGREE_LONG);
    degreeOption.setArgName("degree");
    degreeOption.setDescription(MessageFormat.format(
            "Average number of references per EObject (defaults to {0}). Actual sizes may vary +/- {1}%.",
            GenericMetamodelConfig.DEFAULT_AVERAGE_REFERENCES_SIZE,
            GenericMetamodelConfig.DEFAULT_REFERENCES_DEVIATION * 100));
    degreeOption.setType(Number.class);
    degreeOption.setArgs(1);

    Option forceOption = OptionBuilder.create(FORCE);
    forceOption.setLongOpt(FORCE_LONG);
    forceOption.setDescription("Force the generation, even if input metamodels contain errors");

    Option diagnoseOption = OptionBuilder.create(DIAGNOSE);
    diagnoseOption.setLongOpt(DIAGNOSE_LONG);
    diagnoseOption.setDescription("Run diagnosis on the result model");

    options.addOption(outDirOpt);
    options.addOption(nModelsOpt);
    options.addOption(sizeOption);
    options.addOption(propVariationOption);
    options.addOption(valuesSizeOption);
    options.addOption(degreeOption);
    options.addOption(seedOption);
    options.addOption(forceOption);
    options.addOption(diagnoseOption);
    options.addOption(densityOption);
}

From source file:fr.inria.atlanmod.instantiator.neoEMF.Launcher.java

/**
 * Configures the program options/* w  w w.  j  ava  2 s.  c  o  m*/
 *
 * @param options
 */
private static void configureOptions(Options options) {
    Option metamodelOpt = OptionBuilder.create(E_PACKAGE_CLASS);
    metamodelOpt.setLongOpt(E_PACKAGE_CLASS_LONG);
    metamodelOpt.setArgName("path to the ePackage implementation");
    metamodelOpt.setDescription("PackgeImpl");
    metamodelOpt.setArgs(1);
    metamodelOpt.setRequired(true);

    Option outDirOpt = OptionBuilder.create(OUTPUT_PATH);
    outDirOpt.setLongOpt(OUTPUT_PATH_LONG);
    outDirOpt.setArgName("neoEMF output uri");
    outDirOpt.setDescription("Output directory (defaults to working dir)");
    outDirOpt.setArgs(1);
    outDirOpt.setRequired(true);

    Option nModelsOpt = OptionBuilder.create(N_MODELS);
    nModelsOpt.setLongOpt(N_MODELS_LONG);
    nModelsOpt.setArgName("models");
    nModelsOpt.setDescription("Number of generated models (defaults to 1)");
    nModelsOpt.setType(Number.class);
    nModelsOpt.setArgs(1);

    Option sizeOption = OptionBuilder.create(SIZE);
    sizeOption.setLongOpt(SIZE_LONG);
    sizeOption.setArgName("size");
    sizeOption.setDescription(MessageFormat.format("Average models'' size (defaults to {0})",
            Launcher.DEFAULT_AVERAGE_MODEL_SIZE));
    sizeOption.setType(Number.class);
    sizeOption.setArgs(1);

    Option variationOption = OptionBuilder.create(VARIATION);
    variationOption.setLongOpt(VARIATION_LONG);
    variationOption.setArgName("proportion");
    variationOption.setDescription(MessageFormat
            .format("Variation ([0..1]) in the models'' size (defaults to {0})", Launcher.DEFAULT_DEVIATION));
    variationOption.setType(Number.class);
    variationOption.setArgs(1);

    Option propVariationOption = OptionBuilder.create(PROP_VARIATION);
    propVariationOption.setLongOpt(PROP_VARIATION_LONG);
    propVariationOption.setArgName("properties deviation");
    propVariationOption.setDescription(MessageFormat.format(
            "Variation ([0..1]) in the properties'' size (defaults to {0})", Launcher.DEFAULT_DEVIATION));
    propVariationOption.setType(Number.class);
    propVariationOption.setArgs(1);

    Option seedOption = OptionBuilder.create(SEED);
    seedOption.setLongOpt(SEED_LONG);
    seedOption.setArgName("seed");
    seedOption.setDescription("Seed number (random by default)");
    seedOption.setType(Number.class);
    seedOption.setArgs(1);

    Option valuesSizeOption = OptionBuilder.create(VALUES_SIZE);
    valuesSizeOption.setLongOpt(VALUES_SIZE_LONG);
    valuesSizeOption.setArgName("size");
    valuesSizeOption.setDescription(MessageFormat.format(
            "Average size for attributes with variable length (defaults to {0}). Actual sizes may vary +/- {1}%.",
            GenericMetamodelConfig.DEFAULT_AVERAGE_VALUES_LENGTH,
            GenericMetamodelConfig.DEFAULT_VALUES_DEVIATION * 100));
    valuesSizeOption.setType(Number.class);
    valuesSizeOption.setArgs(1);

    Option degreeOption = OptionBuilder.create(DEGREE);
    degreeOption.setLongOpt(DEGREE_LONG);
    degreeOption.setArgName("degree");
    degreeOption.setDescription(MessageFormat.format(
            "Average number of references per EObject (defaults to {0}). Actual sizes may vary +/- {1}%.",
            GenericMetamodelConfig.DEFAULT_AVERAGE_REFERENCES_SIZE,
            GenericMetamodelConfig.DEFAULT_REFERENCES_DEVIATION * 100));
    degreeOption.setType(Number.class);
    degreeOption.setArgs(1);

    Option forceOption = OptionBuilder.create(FORCE);
    forceOption.setLongOpt(FORCE_LONG);
    forceOption.setDescription("Force the generation, even if input metamodels contain errors");

    Option diagnoseOption = OptionBuilder.create(DIAGNOSE);
    diagnoseOption.setLongOpt(DIAGNOSE_LONG);
    diagnoseOption.setDescription("Run diagnosis on the result model");

    options.addOption(metamodelOpt);
    options.addOption(outDirOpt);
    options.addOption(nModelsOpt);
    options.addOption(sizeOption);
    options.addOption(variationOption);
    options.addOption(propVariationOption);
    options.addOption(valuesSizeOption);
    options.addOption(degreeOption);
    options.addOption(seedOption);
    options.addOption(forceOption);
    options.addOption(diagnoseOption);
}

From source file:net.sourceforge.dita4publishers.tools.ditadxpunpacker.DitaDxpUnpacker.java

/**
 * @return//from  w  ww. ja v a2  s .c om
 */
private static Options configureOptions() {
    Options options = configureOptionsBase();

    options.getOption(INPUT_OPTION_ONE_CHAR).setDescription("(Package file) DXP file to unpack.");
    options.getOption(INPUT_OPTION_ONE_CHAR).setLongOpt("dxpfile");
    options.getOption(OUTPUT_OPTION_ONE_CHAR)
            .setDescription("(Output dir) Directory the DXP package is unpacked into.");

    Option opt = null;

    options.addOption(UNPACK_ALL_OPTION_ONE_CHAR, "unpackAll", false,
            "(Unpack all resources) When specified, indicates that all resources in the package should be unpacked.");
    opt = options.getOption(UNPACK_ALL_OPTION_ONE_CHAR);
    opt.setRequired(false);

    options.addOption(MAPS_ID_OPTION_ONE_CHAR, "mapids", true,
            "(Map IDs) Specifies the IDs (as defined in the DXP package manifest, of the maps to extract.");
    opt = options.getOption(MAPS_ID_OPTION_ONE_CHAR);
    opt.setRequired(false);
    opt.setArgs(Option.UNLIMITED_VALUES);

    return options;
}

From source file:fr.inria.atlanmod.instantiator.SpecimenGenerator.java

/**
 * Configures the program options/*from ww w. ja v  a2  s. c om*/
 *
 * @param options
 */
private static void configureOptions(Options options) {
    Option metamodelOpt = OptionBuilder.create(METAMODEL);
    metamodelOpt.setLongOpt(METAMODEL_LONG);
    metamodelOpt.setArgName("path_to_metamodel.ecore");
    metamodelOpt.setDescription("Ecore metamodel");
    metamodelOpt.setArgs(1);
    metamodelOpt.setRequired(true);

    Option additionalMetamodelOpt = OptionBuilder.create(ADDITIONAL_METAMODEL);
    additionalMetamodelOpt.setLongOpt(ADDITIONAL_METAMODEL_LONG);
    additionalMetamodelOpt.setArgName("path_to_metamodel.ecore");
    additionalMetamodelOpt.setDescription("Additional ecore metamodel(s) that need to be registered");
    additionalMetamodelOpt.setArgs(Option.UNLIMITED_VALUES);

    Option outDirOpt = OptionBuilder.create(OUTPUT_DIR);
    outDirOpt.setLongOpt(OUTPUT_DIR_LONG);
    outDirOpt.setArgName("path_to_output.dir");
    outDirOpt.setDescription("Output directory (defaults to working dir)");
    outDirOpt.setArgs(1);

    Option nModelsOpt = OptionBuilder.create(N_MODELS);
    nModelsOpt.setLongOpt(N_MODELS_LONG);
    nModelsOpt.setArgName("models");
    nModelsOpt.setDescription("Number of generated models (defaults to 1)");
    nModelsOpt.setType(Number.class);
    nModelsOpt.setArgs(1);

    Option sizeOption = OptionBuilder.create(SIZE);
    sizeOption.setLongOpt(SIZE_LONG);
    sizeOption.setArgName("size");
    sizeOption.setDescription("Models' size (defaults to 1000)");
    sizeOption.setType(Number.class);
    sizeOption.setArgs(1);

    Option seedOption = OptionBuilder.create(SEED);
    seedOption.setLongOpt(SEED_LONG);
    seedOption.setArgName("seed");
    seedOption.setDescription("Seed number (random by default)");
    seedOption.setType(Number.class);
    seedOption.setArgs(1);

    options.addOption(metamodelOpt);
    options.addOption(additionalMetamodelOpt);
    options.addOption(outDirOpt);
    options.addOption(nModelsOpt);
    options.addOption(sizeOption);
    options.addOption(seedOption);
}

From source file:lcmc.LCMC.java

/** Inits the application. */
protected static String initApp(final String[] args) {
    try {//from   w  ww  .j av  a  2s. c  om
        /* Metal */
        UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
        MetalLookAndFeel.setCurrentTheme(new OceanTheme() {
            /** e.g. arrows on split pane... */
            protected ColorUIResource getPrimary1() {
                return new ColorUIResource(ClusterBrowser.STATUS_BACKGROUND);
            }

            /** unknown to me */
            protected ColorUIResource getPrimary2() {
                return new ColorUIResource(ClusterBrowser.PANEL_BACKGROUND);
            }

            /** unknown to me */
            protected ColorUIResource getPrimary3() {
                return new ColorUIResource(ClusterBrowser.PANEL_BACKGROUND);
            }

            /** Button and other borders. */
            protected ColorUIResource getSecondary1() {
                return new ColorUIResource(AppDefaults.BACKGROUND_DARK);
            }

            protected ColorUIResource getSecondary2() {
                return new ColorUIResource(ClusterBrowser.PANEL_BACKGROUND);
            }

            /** Split pane divider. Line in the main menu. */
            protected ColorUIResource getSecondary3() {
                return new ColorUIResource(ClusterBrowser.PANEL_BACKGROUND);
            }
        });
    } catch (final Exception e) {
        /* ignore it then */
    }
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
        public void uncaughtException(final Thread t, final Throwable ex) {
            Tools.appError("uncaught exception", ex.toString(), (Exception) ex);
        }
    });
    float fps = 20.0f;
    final Options options = new Options();

    options.addOption("h", HELP_OP, false, "print this help");
    options.addOption(null, KEEP_HELPER_OP, false, "do not overwrite the lcmc-gui-helper program");
    options.addOption(null, RO_OP, false, "read only mode");
    options.addOption(null, OP_OP, false, "operator mode");
    options.addOption(null, ADMIN_OP, false, "administrator mode");
    options.addOption(null, OP_MODE_OP, true, "operating mode. <arg> can be:\n" + "ro - read only\n"
            + "op - operator\n" + "admin - administrator");
    options.addOption(null, NOLRM_OP, false, "do not show removed resources from LRM.");
    options.addOption(null, "auto", true, "for testing");
    options.addOption("v", VERSION_OP, false, "print version");
    options.addOption(null, AUTO_OP, true, "for testing");
    options.addOption(null, NO_UPGRADE_CHECK_OP, false, "disable upgrade check");
    options.addOption(null, NO_PLUGIN_CHECK_OP, false,
            "disable plugin check, DEPRECATED: there are no plugins");
    options.addOption(null, TIGHTVNC_OP, false, "enable tight vnc viewer");
    options.addOption(null, ULTRAVNC_OP, false, "enable ultra vnc viewer");
    options.addOption(null, REALVNC_OP, false, "enable real vnc viewer");
    options.addOption(null, BIGDRBDCONF_OP, false,
            "create one big drbd.conf, instead of many" + " files in drbd.d/ directory");
    options.addOption(null, STAGING_DRBD_OP, false, "enable more DRBD installation options");
    options.addOption(null, STAGING_PACEMAKER_OP, false, "enable more Pacemaker installation options");
    options.addOption(null, VNC_PORT_OFFSET_OP, true, "offset for port forwarding");
    options.addOption(null, SLOW_OP, false, "specify this if you have slow computer");
    options.addOption(null, RESTORE_MOUSE_OP, false, "for testing");
    options.addOption(null, SCALE_OP, true, "scale fonts and sizes of elements in percent (100)");
    options.addOption(null, ID_DSA_OP, true, "location of id_dsa file ($HOME/.ssh/id_dsa)");
    options.addOption(null, ID_RSA_OP, true, "location of id_rsa file ($HOME/.ssh/id_rsa)");
    options.addOption(null, KNOWN_HOSTS_OP, true, "location of known_hosts file ($HOME/.ssh/known_hosts)");
    options.addOption(null, OUT_OP, true, "where to redirect the standard out");
    options.addOption(null, DEBUG_OP, true, "debug level, 0 - none, 3 - all");
    options.addOption("c", CLUSTER_OP, true, "define a cluster");
    final Option hostOp = new Option("h", HOST_OP, true, "define a cluster, used with --cluster option");
    hostOp.setArgs(10000);
    options.addOption(hostOp);
    options.addOption(null, SUDO_OP, false, "whether to use sudo, used with --cluster option");
    options.addOption(null, USER_OP, true, "user to use with sudo, used with --cluster option");
    options.addOption(null, PORT_OP, true, "ssh port, used with --cluster option");
    options.addOption(null, ADVANCED_OP, false, "start in an advanced mode");
    options.addOption(null, ONE_HOST_CLUSTER_OP, false, "allow one host cluster");
    final CommandLineParser parser = new PosixParser();
    String autoArgs = null;
    try {
        final CommandLine cmd = parser.parse(options, args);
        if (cmd.hasOption(OUT_OP)) {
            final String out = cmd.getOptionValue(OUT_OP);
            if (out != null) {
                try {
                    System.setOut(new PrintStream(new FileOutputStream(out)));
                } catch (final FileNotFoundException e) {
                    System.exit(2);
                }
            }
        }
        if (cmd.hasOption(DEBUG_OP)) {
            final String level = cmd.getOptionValue(DEBUG_OP);
            if (level != null && Tools.isNumber(level)) {
                Tools.setDebugLevel(Integer.parseInt(level));
            } else {
                throw new ParseException("cannot parse debug level: " + level);
            }
        }
        boolean tightvnc = cmd.hasOption(TIGHTVNC_OP);
        boolean ultravnc = cmd.hasOption(ULTRAVNC_OP);
        final boolean realvnc = cmd.hasOption(REALVNC_OP);
        if (!tightvnc && !ultravnc && !realvnc) {
            if (Tools.isLinux()) {
                tightvnc = true;
            } else if (Tools.isWindows()) {
                ultravnc = true;
            } else {
                tightvnc = true;
                ultravnc = true;
            }
        }
        boolean advanced = cmd.hasOption(ADVANCED_OP);
        Tools.getConfigData().setAdvancedMode(advanced);
        Tools.getConfigData().setTightvnc(tightvnc);
        Tools.getConfigData().setUltravnc(ultravnc);
        Tools.getConfigData().setRealvnc(realvnc);

        Tools.getConfigData().setUpgradeCheckEnabled(!cmd.hasOption(NO_UPGRADE_CHECK_OP));
        Tools.getConfigData().setBigDRBDConf(cmd.hasOption(BIGDRBDCONF_OP));
        Tools.getConfigData().setStagingDrbd(cmd.hasOption(STAGING_DRBD_OP));
        Tools.getConfigData().setStagingPacemaker(cmd.hasOption(STAGING_PACEMAKER_OP));
        Tools.getConfigData().setNoLRM(cmd.hasOption(NOLRM_OP));
        Tools.getConfigData().setKeepHelper(cmd.hasOption(KEEP_HELPER_OP));
        Tools.getConfigData().setOneHostCluster(cmd.hasOption(ONE_HOST_CLUSTER_OP));
        final String pwd = System.getProperty("user.home");
        final String scaleOp = cmd.getOptionValue(SCALE_OP, "100");
        try {
            final int scale = Integer.parseInt(scaleOp);
            Tools.getConfigData().setScale(scale);
            Tools.resizeFonts(scale);
        } catch (java.lang.NumberFormatException e) {
            Tools.appWarning("cannot parse scale: " + scaleOp);
        }

        final String idDsaPath = cmd.getOptionValue(ID_DSA_OP, pwd + "/.ssh/id_dsa");
        final String idRsaPath = cmd.getOptionValue(ID_RSA_OP, pwd + "/.ssh/id_rsa");
        final String knownHostsPath = cmd.getOptionValue(KNOWN_HOSTS_OP, pwd + "/.ssh/known_hosts");
        Tools.getConfigData().setIdDSAPath(idDsaPath);
        Tools.getConfigData().setIdRSAPath(idRsaPath);
        Tools.getConfigData().setKnownHostPath(knownHostsPath);

        final String opMode = cmd.getOptionValue(OP_MODE_OP);
        autoArgs = cmd.getOptionValue(AUTO_OP);
        if (cmd.hasOption(HELP_OP)) {
            final HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("java -jar LCMC.jar [OPTIONS]", options);
            System.exit(0);
        }
        if (cmd.hasOption(VERSION_OP)) {
            System.out.println("LINUX CLUSTER MANAGEMENT CONSOLE " + Tools.getRelease() + " by Rasto Levrinc");
            System.exit(0);
        }
        if (cmd.hasOption("ro") || "ro".equals(opMode)) {
            Tools.getConfigData().setAccessType(ConfigData.AccessType.RO);
            Tools.getConfigData().setMaxAccessType(ConfigData.AccessType.RO);
        } else if (cmd.hasOption("op") || "op".equals(opMode)) {
            Tools.getConfigData().setAccessType(ConfigData.AccessType.OP);
            Tools.getConfigData().setMaxAccessType(ConfigData.AccessType.OP);
        } else if (cmd.hasOption("admin") || "admin".equals(opMode)) {
            Tools.getConfigData().setAccessType(ConfigData.AccessType.ADMIN);
            Tools.getConfigData().setMaxAccessType(ConfigData.AccessType.ADMIN);
        } else if (opMode != null) {
            Tools.appWarning("unknown operating mode: " + opMode);
        }
        if (cmd.hasOption(SLOW_OP)) {
            fps = fps / 2;
        }
        if (cmd.hasOption(RESTORE_MOUSE_OP)) {
            /* restore mouse if it is stuck in pressed state, during
             * robot tests. */
            RoboTest.restoreMouse();
        }
        final String vncPortOffsetString = cmd.getOptionValue(VNC_PORT_OFFSET_OP);
        if (vncPortOffsetString != null && Tools.isNumber(vncPortOffsetString)) {
            Tools.getConfigData().setVncPortOffset(Integer.parseInt(vncPortOffsetString));
        }
        Tools.getConfigData().setAnimFPS(fps);
        if (cmd.hasOption(CLUSTER_OP) || cmd.hasOption(HOST_OP)) {
            parseClusterOptions(cmd);
        }
    } catch (ParseException exp) {
        System.out.println("ERROR: " + exp.getMessage());
        System.exit(1);
    }
    Tools.debug(null, "max mem: " + Runtime.getRuntime().maxMemory() / 1024 / 1024 + "m", 1);
    return autoArgs;
}

From source file:com.linkedin.helix.tools.ClusterStateVerifier.java

@SuppressWarnings("static-access")
private static Options constructCommandLineOptions() {
    Option helpOption = OptionBuilder.withLongOpt(help).withDescription("Prints command-line options info")
            .create();/*from w  w  w .  j a va  2 s .c o m*/

    Option zkServerOption = OptionBuilder.withLongOpt(zkServerAddress)
            .withDescription("Provide zookeeper address").create();
    zkServerOption.setArgs(1);
    zkServerOption.setRequired(true);
    zkServerOption.setArgName("ZookeeperServerAddress(Required)");

    Option clusterOption = OptionBuilder.withLongOpt(cluster).withDescription("Provide cluster name").create();
    clusterOption.setArgs(1);
    clusterOption.setRequired(true);
    clusterOption.setArgName("Cluster name (Required)");

    Option timeoutOption = OptionBuilder.withLongOpt(timeout).withDescription("Timeout value for verification")
            .create();
    timeoutOption.setArgs(1);
    timeoutOption.setArgName("Timeout value (Optional), default=30s");

    Option sleepIntervalOption = OptionBuilder.withLongOpt(period)
            .withDescription("Polling period for verification").create();
    sleepIntervalOption.setArgs(1);
    sleepIntervalOption.setArgName("Polling period value (Optional), default=1s");

    Options options = new Options();
    options.addOption(helpOption);
    options.addOption(zkServerOption);
    options.addOption(clusterOption);
    options.addOption(timeoutOption);
    options.addOption(sleepIntervalOption);

    return options;
}