Example usage for org.apache.commons.cli Options addOptionGroup

List of usage examples for org.apache.commons.cli Options addOptionGroup

Introduction

In this page you can find the example usage for org.apache.commons.cli Options addOptionGroup.

Prototype

public Options addOptionGroup(OptionGroup group) 

Source Link

Document

Add the specified option group.

Usage

From source file:com.github.jmabuin.blaspark.examples.options.GeneralOptions.java

public Options initOptions() {

    Options privateOptions = new Options();

    OptionGroup general = new OptionGroup();

    // Options: h, d, s, c, j, i, l, o, b, p

    // Help//w  w w .  j  a  v a2  s  .c o m
    Option help = new Option("h", "help", false, "Shows documentation");
    general.addOption(help);

    privateOptions.addOptionGroup(general);

    // Operations
    OptionGroup operations = new OptionGroup();

    Option dmxv = new Option("d", "dmxv", false, "Performs a distributed dense matrix dot vector operation");
    operations.addOption(dmxv);

    Option smxv = new Option("s", "smxv", false, "Performs a distributed sparse matrix dot vector operation");
    operations.addOption(smxv);

    Option conjGrad = new Option("c", "conjGrad", false,
            "Solves a system by using the conjugate gradient method");
    operations.addOption(conjGrad);

    Option jacobi = new Option("j", "jacobi", false, "Solves a system by using the Jacobi method");
    operations.addOption(jacobi);

    Option dmxdm = new Option("m", "dmxdm", false,
            "Performs a distributed dense matrix dot distributed dense matrix operation");
    operations.addOption(dmxdm);

    privateOptions.addOptionGroup(operations);

    // Number of iterations for CG
    Option iteration = new Option("i", "iteration", true,
            "Number of iterations to perform the conjugate gradient method");
    privateOptions.addOption(iteration);

    // Matrix formats
    OptionGroup matrixFormat = new OptionGroup();
    Option pairLine = new Option("l", "pairLine", false, "The matrix format will be a IndexedRowMatrix");
    matrixFormat.addOption(pairLine);

    Option coordinate = new Option("o", "coordinate", false, "The matrix format will be a CoordinateMatrix");
    matrixFormat.addOption(coordinate);

    Option blocked = new Option("b", "blocked", false, "The matrix format will be a BlockMatrix");
    matrixFormat.addOption(blocked);

    privateOptions.addOptionGroup(matrixFormat);

    // Partition number
    Option partitions = new Option("p", "partitions", true, "Number of partitions to divide the matrix");
    privateOptions.addOption(partitions);

    // Rows and cols per block for blocked format
    Option rowsPerBlock = new Option(null, "rows", true, "Number of rows for block in BlockMatrix format");
    privateOptions.addOption(rowsPerBlock);

    Option colsPerBlock = new Option(null, "cols", true, "Number of cols for block in BlockMatrix format");
    privateOptions.addOption(colsPerBlock);

    // Alpha and beta for DMxV operation
    Option alpha = new Option(null, "alpha", true, "Alpha value for DMxV example");
    privateOptions.addOption(alpha);

    Option beta = new Option(null, "beta", true, "Beta value for DMxV example");
    privateOptions.addOption(beta);

    return privateOptions;
}

From source file:com.github.lindenb.jvarkit.util.command.Command.java

protected void fillOptions(final Options opts) {
    final OptionGroup g = new OptionGroup();
    g.addOption(createHelpOption());/*from   w w w .j  a v a2  s . c  o m*/
    g.addOption(createVersionOption());
    opts.addOptionGroup(g);
}

From source file:de.zib.scalaris.InterOpTest.java

/**
 * Creates the options the command line should understand.
 *
 * @return the options the program understands
 *//*  w  ww  . j  a v a  2s.c o m*/
private static Options getOptions() {
    final Options options = new Options();
    final OptionGroup group = new OptionGroup();

    /* Note: arguments are set to be optional since we implement argument
     * checks on our own (commons.cli is not flexible enough and only
     * checks for the existence of a first argument)
     */

    options.addOption(new Option("h", "help", false, "print this message"));

    options.addOption(new Option("v", "verbose", false, "print verbose information, e.g. the properties read"));

    final Option read = new Option("r", "read", true, "read an item");
    read.setArgName("basekey> <language");
    read.setArgs(2);
    read.setOptionalArg(true);
    group.addOption(read);

    final Option write = new Option("w", "write", true, "write an item");
    write.setArgName("basekey");
    write.setArgs(1);
    write.setOptionalArg(true);
    group.addOption(write);

    options.addOptionGroup(group);

    options.addOption(new Option("lh", "localhost", false,
            "gets the local host's name as known to Java (for debugging purposes)"));

    return options;
}

From source file:com.github.lindenb.jvarkit.util.command.CommandFactory.java

protected void fillOptions(final Options opts) {
    final OptionGroup g = new OptionGroup();
    g.addOption(createHelpOption());/*from   w w w  .  j  a v  a2  s  .  c om*/
    g.addOption(createVersionOption());
    g.addOption(Option.builder("proxy").required(false).longOpt("proxy").hasArg(true).argName("HOST:PORT")
            .desc("set the http and the https proxy.").build());
    opts.addOptionGroup(g);
}

From source file:gobblin.cli.JobCommand.java

private Options createCommandLineOptions() {
    Options options = new Options();

    OptionGroup actionGroup = new OptionGroup();
    actionGroup.addOption(new Option("h", HELP_OPT, false, "Shows the help message."));
    actionGroup.addOption(new Option("d", DETAILS_OPT, false, "Show details about a job/task."));
    actionGroup.addOption(new Option("l", LIST_OPT, false, "List jobs/tasks."));
    actionGroup.addOption(new Option("p", PROPS_OPT, false, "Fetch properties with the query."));
    actionGroup.setRequired(true);/*from  ww  w. j a  v a  2  s. co  m*/
    options.addOptionGroup(actionGroup);

    OptionGroup idGroup = new OptionGroup();
    idGroup.addOption(new Option("j", NAME_OPT, true, "Find job(s) matching given job name."));
    idGroup.addOption(new Option("i", ID_OPT, true, "Find the job/task with the given id."));
    options.addOptionGroup(idGroup);

    options.addOption("n", true,
            "Limit the number of results returned. (default:" + DEFAULT_RESULTS_LIMIT + ")");
    options.addOption("r", RECENT_OPT, false, "List the most recent jobs (instead of a list of unique jobs)");

    return options;
}

From source file:com.opengamma.integration.tool.portfolio.PortfolioDeleteTool.java

@Override
protected Options createOptions(boolean contextProvided) {

    Options options = super.createOptions(contextProvided);

    Option portfolioNamesOption = new Option(PORTFOLIO_NAMES_OPT, "name", true,
            "Regular expression to match portfolio names");
    //    options.addOption(portfolioNamesOption);

    Option deletePortfolioIdsOption = new Option(PORTFOLIO_IDS_OPT, "portfolioid", true,
            "Portfolio IDs to match");
    //    options.addOption(deletePortfolioIdsOption);

    OptionGroup group = new OptionGroup();
    group.addOption(deletePortfolioIdsOption);
    group.addOption(portfolioNamesOption);
    group.setRequired(true);//  ww  w  .  ja v  a2s. c o  m

    options.addOptionGroup(group);

    Option deletePositionsOption = new Option(DELETE_POSITIONS_OPT, "delpositions", false,
            "Match/delete positions referenced in matching portfolios");
    options.addOption(deletePositionsOption);

    Option deleteSecuritiesOption = new Option(DELETE_SECURITIES_OPT, "delsecurities", false,
            "Match/delete securities referenced in matching portfolios");
    options.addOption(deleteSecuritiesOption);

    Option deletePortfoliosOption = new Option(DELETE_PORTFOLIOS_OPT, "delportfolios", false,
            "Actually delete matching portfolios");
    options.addOption(deletePortfoliosOption);

    Option writeOption = new Option(WRITE_OPT, "write", false, "Actually persist the deletions");
    options.addOption(writeOption);

    Option verboseOption = new Option(VERBOSE_OPT, "verbose", false,
            "Displays progress messages on the terminal");
    options.addOption(verboseOption);

    return options;
}

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

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

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

    Option listClustersOption = OptionBuilder.withLongOpt(listClusters)
            .withDescription("List existing clusters").create();
    listClustersOption.setArgs(0);
    listClustersOption.setRequired(false);

    Option listResourceOption = OptionBuilder.withLongOpt(listResources)
            .withDescription("List resources hosted in a cluster").create();
    listResourceOption.setArgs(1);
    listResourceOption.setRequired(false);
    listResourceOption.setArgName("clusterName");

    Option listInstancesOption = OptionBuilder.withLongOpt(listInstances)
            .withDescription("List Instances in a cluster").create();
    listInstancesOption.setArgs(1);
    listInstancesOption.setRequired(false);
    listInstancesOption.setArgName("clusterName");

    Option addClusterOption = OptionBuilder.withLongOpt(addCluster).withDescription("Add a new cluster")
            .create();
    addClusterOption.setArgs(1);
    addClusterOption.setRequired(false);
    addClusterOption.setArgName("clusterName");

    Option activateClusterOption = OptionBuilder.withLongOpt(activateCluster)
            .withDescription("Enable/disable a cluster in distributed controller mode").create();
    activateClusterOption.setArgs(3);
    activateClusterOption.setRequired(false);
    activateClusterOption.setArgName("clusterName grandCluster true/false");

    Option deleteClusterOption = OptionBuilder.withLongOpt(dropCluster).withDescription("Delete a cluster")
            .create();
    deleteClusterOption.setArgs(1);
    deleteClusterOption.setRequired(false);
    deleteClusterOption.setArgName("clusterName");

    Option addInstanceOption = OptionBuilder.withLongOpt(addInstance)
            .withDescription("Add a new Instance to a cluster").create();
    addInstanceOption.setArgs(2);
    addInstanceOption.setRequired(false);
    addInstanceOption.setArgName("clusterName InstanceAddress(host:port)");

    Option addResourceOption = OptionBuilder.withLongOpt(addResource)
            .withDescription("Add a resource to a cluster").create();
    addResourceOption.setArgs(4);
    addResourceOption.setRequired(false);
    addResourceOption.setArgName("clusterName resourceName partitionNum stateModelRef <-mode modeValue>");

    Option expandResourceOption = OptionBuilder.withLongOpt(expandResource)
            .withDescription("Expand resource to additional nodes").create();
    expandResourceOption.setArgs(2);
    expandResourceOption.setRequired(false);
    expandResourceOption.setArgName("clusterName resourceName");

    Option expandClusterOption = OptionBuilder.withLongOpt(expandCluster)
            .withDescription("Expand a cluster and all the resources").create();
    expandClusterOption.setArgs(1);
    expandClusterOption.setRequired(false);
    expandClusterOption.setArgName("clusterName");

    Option resourceModeOption = OptionBuilder.withLongOpt(mode)
            .withDescription("Specify resource mode, used with addResourceGroup command").create();
    resourceModeOption.setArgs(1);
    resourceModeOption.setRequired(false);
    resourceModeOption.setArgName("IdealState mode");

    Option resourceBucketSizeOption = OptionBuilder.withLongOpt(bucketSize)
            .withDescription("Specify size of a bucket, used with addResourceGroup command").create();
    resourceBucketSizeOption.setArgs(1);
    resourceBucketSizeOption.setRequired(false);
    resourceBucketSizeOption.setArgName("Size of a bucket for a resource");

    Option resourceKeyOption = OptionBuilder.withLongOpt(resourceKeyPrefix)
            .withDescription("Specify resource key prefix, used with rebalance command").create();
    resourceKeyOption.setArgs(1);
    resourceKeyOption.setRequired(false);
    resourceKeyOption.setArgName("Resource key prefix");

    Option addStateModelDefOption = OptionBuilder.withLongOpt(addStateModelDef)
            .withDescription("Add a State model to a cluster").create();
    addStateModelDefOption.setArgs(2);
    addStateModelDefOption.setRequired(false);
    addStateModelDefOption.setArgName("clusterName <filename>");

    Option addIdealStateOption = OptionBuilder.withLongOpt(addIdealState)
            .withDescription("Add a State model to a cluster").create();
    addIdealStateOption.setArgs(3);
    addIdealStateOption.setRequired(false);
    addIdealStateOption.setArgName("clusterName resourceName <filename>");

    Option dropInstanceOption = OptionBuilder.withLongOpt(dropInstance)
            .withDescription("Drop an existing Instance from a cluster").create();
    dropInstanceOption.setArgs(2);
    dropInstanceOption.setRequired(false);
    dropInstanceOption.setArgName("clusterName InstanceAddress(host:port)");

    Option swapInstanceOption = OptionBuilder.withLongOpt(swapInstance)
            .withDescription("Swap an old instance from a cluster with a new instance").create();
    swapInstanceOption.setArgs(3);
    swapInstanceOption.setRequired(false);
    swapInstanceOption.setArgName("clusterName oldInstance newInstance");

    Option dropResourceOption = OptionBuilder.withLongOpt(dropResource)
            .withDescription("Drop an existing resource from a cluster").create();
    dropResourceOption.setArgs(2);
    dropResourceOption.setRequired(false);
    dropResourceOption.setArgName("clusterName resourceName");

    Option rebalanceOption = OptionBuilder.withLongOpt(rebalance)
            .withDescription("Rebalance a resource in a cluster").create();
    rebalanceOption.setArgs(3);
    rebalanceOption.setRequired(false);
    rebalanceOption.setArgName("clusterName resourceName replicas");

    Option instanceInfoOption = OptionBuilder.withLongOpt(listInstanceInfo)
            .withDescription("Query info of a Instance in a cluster").create();
    instanceInfoOption.setArgs(2);
    instanceInfoOption.setRequired(false);
    instanceInfoOption.setArgName("clusterName InstanceName");

    Option clusterInfoOption = OptionBuilder.withLongOpt(listClusterInfo)
            .withDescription("Query info of a cluster").create();
    clusterInfoOption.setArgs(1);
    clusterInfoOption.setRequired(false);
    clusterInfoOption.setArgName("clusterName");

    Option resourceInfoOption = OptionBuilder.withLongOpt(listResourceInfo)
            .withDescription("Query info of a resource").create();
    resourceInfoOption.setArgs(2);
    resourceInfoOption.setRequired(false);
    resourceInfoOption.setArgName("clusterName resourceName");

    Option addResourcePropertyOption = OptionBuilder.withLongOpt(addResourceProperty)
            .withDescription("Add a resource property").create();
    addResourcePropertyOption.setArgs(4);
    addResourcePropertyOption.setRequired(false);
    addResourcePropertyOption.setArgName("clusterName resourceName propertyName propertyValue");

    Option removeResourcePropertyOption = OptionBuilder.withLongOpt(removeResourceProperty)
            .withDescription("Remove a resource property").create();
    removeResourcePropertyOption.setArgs(3);
    removeResourcePropertyOption.setRequired(false);
    removeResourcePropertyOption.setArgName("clusterName resourceName propertyName");

    Option partitionInfoOption = OptionBuilder.withLongOpt(listPartitionInfo)
            .withDescription("Query info of a partition").create();
    partitionInfoOption.setArgs(3);
    partitionInfoOption.setRequired(false);
    partitionInfoOption.setArgName("clusterName resourceName partitionName");

    Option enableInstanceOption = OptionBuilder.withLongOpt(enableInstance)
            .withDescription("Enable/disable a Instance").create();
    enableInstanceOption.setArgs(3);
    enableInstanceOption.setRequired(false);
    enableInstanceOption.setArgName("clusterName InstanceName true/false");

    Option enablePartitionOption = OptionBuilder.hasArgs().withLongOpt(enablePartition)
            .withDescription("Enable/disable partitions").create();
    enablePartitionOption.setRequired(false);
    enablePartitionOption.setArgName("true/false clusterName instanceName resourceName partitionName1...");

    Option enableClusterOption = OptionBuilder.withLongOpt(enableCluster)
            .withDescription("pause/resume the controller of a cluster").create();
    enableClusterOption.setArgs(2);
    enableClusterOption.setRequired(false);
    enableClusterOption.setArgName("clusterName true/false");

    Option resetPartitionOption = OptionBuilder.withLongOpt(resetPartition)
            .withDescription("Reset a partition in error state").create();
    resetPartitionOption.setArgs(4);
    resetPartitionOption.setRequired(false);
    resetPartitionOption.setArgName("clusterName instanceName resourceName partitionName");

    Option resetInstanceOption = OptionBuilder.withLongOpt(resetInstance)
            .withDescription("Reset all partitions in error state for an instance").create();
    resetInstanceOption.setArgs(2);
    resetInstanceOption.setRequired(false);
    resetInstanceOption.setArgName("clusterName instanceName");

    Option resetResourceOption = OptionBuilder.withLongOpt(resetResource)
            .withDescription("Reset all partitions in error state for a resource").create();
    resetResourceOption.setArgs(2);
    resetResourceOption.setRequired(false);
    resetResourceOption.setArgName("clusterName resourceName");

    Option listStateModelsOption = OptionBuilder.withLongOpt(listStateModels)
            .withDescription("Query info of state models in a cluster").create();
    listStateModelsOption.setArgs(1);
    listStateModelsOption.setRequired(false);
    listStateModelsOption.setArgName("clusterName");

    Option listStateModelOption = OptionBuilder.withLongOpt(listStateModel)
            .withDescription("Query info of a state model in a cluster").create();
    listStateModelOption.setArgs(2);
    listStateModelOption.setRequired(false);
    listStateModelOption.setArgName("clusterName stateModelName");

    Option addStatOption = OptionBuilder.withLongOpt(addStat).withDescription("Add a persistent stat").create();
    addStatOption.setArgs(2);
    addStatOption.setRequired(false);
    addStatOption.setArgName("clusterName statName");
    Option addAlertOption = OptionBuilder.withLongOpt(addAlert).withDescription("Add an alert").create();
    addAlertOption.setArgs(2);
    addAlertOption.setRequired(false);
    addAlertOption.setArgName("clusterName alertName");

    Option dropStatOption = OptionBuilder.withLongOpt(dropStat).withDescription("Drop a persistent stat")
            .create();
    dropStatOption.setArgs(2);
    dropStatOption.setRequired(false);
    dropStatOption.setArgName("clusterName statName");
    Option dropAlertOption = OptionBuilder.withLongOpt(dropAlert).withDescription("Drop an alert").create();
    dropAlertOption.setArgs(2);
    dropAlertOption.setRequired(false);
    dropAlertOption.setArgName("clusterName alertName");

    // set/get configs option
    Option setConfOption = OptionBuilder.withLongOpt(setConfig).withDescription("Set a config").create();
    setConfOption.setArgs(2);
    setConfOption.setRequired(false);
    setConfOption
            .setArgName("ConfigScope(e.g. CLUSTER=cluster,RESOURCE=rc,...) KeyValueMap(e.g. k1=v1,k2=v2,...)");

    Option getConfOption = OptionBuilder.withLongOpt(getConfig).withDescription("Get a config").create();
    getConfOption.setArgs(2);
    getConfOption.setRequired(false);
    getConfOption.setArgName("ConfigScope(e.g. CLUSTER=cluster,RESOURCE=rc,...) KeySet(e.g. k1,k2,...)");

    OptionGroup group = new OptionGroup();
    group.setRequired(true);
    group.addOption(rebalanceOption);
    group.addOption(addResourceOption);
    group.addOption(resourceModeOption);
    group.addOption(resourceBucketSizeOption);
    group.addOption(expandResourceOption);
    group.addOption(expandClusterOption);
    group.addOption(resourceKeyOption);
    group.addOption(addClusterOption);
    group.addOption(activateClusterOption);
    group.addOption(deleteClusterOption);
    group.addOption(addInstanceOption);
    group.addOption(listInstancesOption);
    group.addOption(listResourceOption);
    group.addOption(listClustersOption);
    group.addOption(addIdealStateOption);
    group.addOption(rebalanceOption);
    group.addOption(dropInstanceOption);
    group.addOption(swapInstanceOption);
    group.addOption(dropResourceOption);
    group.addOption(instanceInfoOption);
    group.addOption(clusterInfoOption);
    group.addOption(resourceInfoOption);
    group.addOption(partitionInfoOption);
    group.addOption(enableInstanceOption);
    group.addOption(enablePartitionOption);
    group.addOption(enableClusterOption);
    group.addOption(resetPartitionOption);
    group.addOption(resetInstanceOption);
    group.addOption(resetResourceOption);
    group.addOption(addStateModelDefOption);
    group.addOption(listStateModelsOption);
    group.addOption(listStateModelOption);
    group.addOption(addStatOption);
    group.addOption(addAlertOption);
    group.addOption(dropStatOption);
    group.addOption(dropAlertOption);
    group.addOption(setConfOption);
    group.addOption(getConfOption);
    group.addOption(addResourcePropertyOption);
    group.addOption(removeResourcePropertyOption);

    Options options = new Options();
    options.addOption(helpOption);
    options.addOption(zkServerOption);
    options.addOptionGroup(group);
    return options;
}

From source file:com.zimbra.cs.volume.VolumeCLI.java

@Override
protected void setupCommandLineOptions() {
    super.setupCommandLineOptions();
    Options options = getOptions();
    OptionGroup og = new OptionGroup();
    og.addOption(new Option(O_A, "add", false, "Adds a volume."));
    og.addOption(new Option(O_D, "delete", false, "Deletes a volume."));
    og.addOption(new Option(O_L, "list", false, "Lists volumes."));
    og.addOption(new Option(O_E, "edit", false, "Edits a volume."));
    og.addOption(new Option(O_DC, "displayCurrent", false, "Displays the current volumes."));
    og.addOption(new Option(O_SC, "setCurrent", false, "Sets the current volume."));
    og.addOption(new Option(O_TS, "turnOffSecondary", false, "Turns off the current secondary message volume"));
    og.setRequired(true);/*from  w ww.  j av  a2 s  .c o m*/
    options.addOptionGroup(og);
    options.addOption(O_ID, "id", true, "Volume ID");
    options.addOption(O_T, "type", true, "Volume type (primaryMessage, secondaryMessage, or index)");
    options.addOption(O_N, "name", true, "volume name");
    options.addOption(O_P, "path", true, "Root path");
    options.addOption(O_C, "compress", true, "Compress blobs; \"true\" or \"false\"");
    options.addOption(O_CT, "compressionThreshold", true, "Compression threshold; default 4KB");
    options.addOption(SoapCLI.OPT_AUTHTOKEN);
    options.addOption(SoapCLI.OPT_AUTHTOKENFILE);
}

From source file:com.zimbra.cs.util.SoapCLI.java

/**
 * Returns an <tt>Options</tt> object that combines the standard options
 * and the hidden ones./* w ww  . ja v a 2  s. c o m*/
 */
@SuppressWarnings("unchecked")
private Options getAllOptions() {
    Options newOptions = new Options();
    Set<OptionGroup> groups = new HashSet<OptionGroup>();
    Options[] optionses = new Options[] { mOptions, mHiddenOptions };
    for (Options options : optionses) {
        for (Option opt : (Collection<Option>) options.getOptions()) {
            OptionGroup group = options.getOptionGroup(opt);
            if (group != null) {
                groups.add(group);
            } else {
                newOptions.addOption(opt);
            }
        }
    }

    for (OptionGroup group : groups) {
        newOptions.addOptionGroup(group);
    }
    return newOptions;
}

From source file:com.netspective.sparx.security.authenticator.SingleUserServletLoginAuthenticator.java

private Options createAuthenticatorOptions() {
    Options authenticatorOptions = new Options();
    authenticatorOptions.addOption(//from www .j a  v a  2s.  c om
            OptionBuilder.withLongOpt("help").withDescription("Print options to stdout").create('?'));
    authenticatorOptions.addOption(OptionBuilder.withLongOpt("user-id").hasArg().withArgName("id")
            .withDescription("The user id that should be used to log the user in").isRequired().create('u'));
    authenticatorOptions.addOption(OptionBuilder.withLongOpt("show-encrypted-password")
            .withDescription("Prints the encrypted version of plain-text password to stdout").create('s'));

    OptionGroup passwordOptionGroup = new OptionGroup();
    passwordOptionGroup.setRequired(true);
    passwordOptionGroup.addOption(OptionBuilder.withLongOpt("plain-text-password").hasArg()
            .withArgName("plain-text").withDescription("The plain-text password for the user").create('p'));
    passwordOptionGroup.addOption(OptionBuilder.withLongOpt("encrypted-password").hasArg()
            .withArgName("encrypted-text").withDescription("The encrypted password for the user").create('P'));

    authenticatorOptions.addOptionGroup(passwordOptionGroup);
    return authenticatorOptions;
}