Example usage for org.apache.commons.cli DefaultParser DefaultParser

List of usage examples for org.apache.commons.cli DefaultParser DefaultParser

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

Introduction

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

Prototype

DefaultParser

Source Link

Usage

From source file:de.tudarmstadt.ukp.dkpro.core.mallet.lda.util.PrintTopWords.java

private static void setOptions(String[] args) {
    Options options = new Options();
    options.addOption("m", "model", true, "The model file");
    options.addOption("n", "nWords", true, "The number of topic words to print. Default: 10.");

    CommandLineParser parser = new DefaultParser();
    CommandLine cli;/*  ww  w  .ja  v  a  2  s .  c  om*/
    try {
        cli = parser.parse(options, args);
        modelFile = new File(cli.getOptionValue("model"));
        nWords = Integer.parseInt(cli.getOptionValue("nWords", "10"));
    } catch (ParseException | NullPointerException e) {
        new HelpFormatter().printHelp("java -jar PrintTopicWords.jar", options);
        throw new IllegalArgumentException(e);
    }
}

From source file:com.mycompany.sparkrentals.Main.java

/**
 * This program can be run with arguments -solr [solr url] -cql [cassandra
 * url] -keyspace [keyspace name] this will override the default settings
 *
 * @param args//from   ww w. j  a  v  a 2 s  . c  om
 */
private static void initializeSolrCqlHostsFromArgs(String[] args) {
    solrUrl = "http://localhost:8983/solr/new_core";
    cqlHost = "127.0.0.1";
    cqlKeyspace = "rentalskeyspace";

    Options options = new Options();
    options.addOption("solr", true, "Solr host url");
    options.addOption("cql", true, "cassandra host address");
    options.addOption("keyspace", true, "cassandra keyspace name");
    CommandLineParser parser = new DefaultParser();
    CommandLine cmd;
    try {
        cmd = parser.parse(options, args);
    } catch (ParseException e) {
        System.out
                .println("run with arguments -solr [solr url] -cql [cassandra url] -keyspace [keyspace name]");
        return;
    }
    if (cmd.hasOption("solr")) {
        solrUrl = cmd.getOptionValue("solr");
        System.out.println("SolrUrl = " + solrUrl);
    }
    if (cmd.hasOption("cql")) {
        cqlHost = cmd.getOptionValue("cql");
    }
    if (cmd.hasOption("keyspace")) {
        cqlKeyspace = cmd.getOptionValue("keyspace");
    }
}

From source file:com.uber.stream.kafka.mirrormaker.manager.TestManagerConf.java

@Test
public void testDefaultCmdControllerConf() throws ParseException {
    try {//from ww w.  j a  v  a2  s  .  c om
        String[] args = new String[] {};

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.fail("Expected exception to be thrown");
    } catch (RuntimeException e) {
        Assert.assertTrue(e.getMessage().equals("Missing option: --zookeeper"));
    }

    try {
        String[] args = new String[] { "-zookeeper", "localhost:2181/test" };

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.fail("Expected exception to be thrown");
    } catch (RuntimeException e) {
        Assert.assertTrue(e.getMessage().equals("Missing option: --managerPort"));
    }

    try {
        String[] args = new String[] { "-zookeeper", "localhost:2181/test", "-managerPort", "9090" };

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.fail("Expected exception to be thrown");
    } catch (RuntimeException e) {
        Assert.assertTrue(e.getMessage().equals("Missing option: --deployment"));
    }

    try {
        String[] args = new String[] { "-zookeeper", "localhost:2181/test", "-managerPort", "9090",
                "-deployment", "testing" };

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.fail("Expected exception to be thrown");
    } catch (RuntimeException e) {
        Assert.assertTrue(e.getMessage().equals("Missing option: --env"));
    }

    try {
        String[] args = new String[] { "-zookeeper", "localhost:2181/test", "-managerPort", "9090",
                "-deployment", "testing", "-env", "dc.testing" };

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.fail("Expected exception to be thrown");
    } catch (RuntimeException e) {
        Assert.assertTrue(e.getMessage().equals("Missing option: --controllerPort"));
    }

    try {
        String[] args = new String[] { "-zookeeper", "localhost:2181/test", "-managerPort", "9090",
                "-deployment", "testing", "-controllerPort", "8080", "-env", "dc.testing" };

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(ManagerConf.constructManagerOptions(), args);
        ManagerConf conf = ManagerConf.getManagerConf(cmd);
        Assert.assertTrue(conf.getSourceClusters().isEmpty());
        Assert.assertTrue(conf.getDestinationClusters().isEmpty());
        Assert.assertEquals(conf.getManagerZkStr(), "localhost:2181/test");
        Assert.assertEquals(conf.getManagerPort().toString(), "9090");
        Assert.assertEquals(conf.getManagerDeployment(), "testing");
        Assert.assertEquals(conf.getManagerInstanceId(), InetAddress.getLocalHost().getHostName());
        Assert.assertEquals(conf.getControllerPort().toString(), "8080");
        Assert.assertEquals(conf.getC3Host(), "localhost");
        Assert.assertEquals(conf.getC3Port().toString(), "0");
        Assert.assertEquals(conf.getWorkloadRefreshPeriodInSeconds().toString(), "600");
        Assert.assertEquals(conf.getInitMaxNumPartitionsPerRoute().toString(), "10");
        Assert.assertEquals(conf.getMaxNumPartitionsPerRoute().toString(), "20");
        Assert.assertEquals(conf.getInitMaxNumWorkersPerRoute().toString(), "3");
        Assert.assertEquals(conf.getMaxNumWorkersPerRoute().toString(), "5");
    } catch (Exception e) {
        Assert.fail("No exception is expected");
    }
}

From source file:at.favre.tools.dconvert.ui.CLIInterpreter.java

public static Arguments parse(String[] args) {
    ResourceBundle strings = ResourceBundle.getBundle("bundles.strings", Locale.getDefault());
    Options options = setupOptions(strings);
    CommandLineParser parser = new DefaultParser();

    Arguments.Builder builder;/* w  w w. j a va 2 s.com*/
    try {
        CommandLine commandLine = parser.parse(options, args);

        if (commandLine.hasOption("gui")) {
            return Arguments.START_GUI;
        }

        if (commandLine.hasOption("h") || commandLine.hasOption("help")) {
            printHelp(options);
            return null;
        }

        if (commandLine.hasOption("v") || commandLine.hasOption("version")) {
            System.out.println("Version: " + CLIInterpreter.class.getPackage().getImplementationVersion());
            return null;
        }

        String scaleRawParam = commandLine.getOptionValue(SCALE_ARG).toLowerCase();

        boolean dp = false;

        if (scaleRawParam.contains("dp")) {
            dp = true;
            scaleRawParam = scaleRawParam.replace("dp", "").trim();
        }

        builder = new Arguments.Builder(new File(commandLine.getOptionValue(SOURCE_ARG)),
                Float.parseFloat(scaleRawParam));

        if (dp && commandLine.hasOption(SCALE_IS_HEIGHT_DP_ARG)) {
            builder.scaleMode(EScaleMode.DP_HEIGHT);
        } else if (dp && !commandLine.hasOption(SCALE_IS_HEIGHT_DP_ARG)) {
            builder.scaleMode(EScaleMode.DP_WIDTH);
        } else {
            builder.scaleMode(EScaleMode.FACTOR);
        }

        if (commandLine.hasOption(DST_ARG)) {
            builder.dstFolder(new File(commandLine.getOptionValue(DST_ARG)));
        }

        float compressionQuality = Arguments.DEFAULT_COMPRESSION_QUALITY;
        if (commandLine.hasOption(COMPRESSION_QUALITY_ARG)) {
            compressionQuality = Float.valueOf(commandLine.getOptionValue(COMPRESSION_QUALITY_ARG));
        }

        if (commandLine.hasOption(OUT_COMPRESSION_ARG)) {
            switch (commandLine.getOptionValue(OUT_COMPRESSION_ARG)) {
            case "strict":
                builder.compression(EOutputCompressionMode.SAME_AS_INPUT_STRICT);
                break;
            case "png":
                builder.compression(EOutputCompressionMode.AS_PNG);
                break;
            case "jpg":
                builder.compression(EOutputCompressionMode.AS_JPG, compressionQuality);
                break;
            case "gif":
                builder.compression(EOutputCompressionMode.AS_GIF);
                break;
            case "bmp":
                builder.compression(EOutputCompressionMode.AS_BMP);
                break;
            case "png+jpg":
                builder.compression(EOutputCompressionMode.AS_JPG_AND_PNG, compressionQuality);
                break;
            default:
                System.err.println(
                        "unknown compression type: " + commandLine.getOptionValue(OUT_COMPRESSION_ARG));
            }
        }

        Set<EPlatform> platformSet = new HashSet<>(EPlatform.values().length);
        if (commandLine.hasOption(PLATFORM_ARG)) {
            switch (commandLine.getOptionValue(PLATFORM_ARG)) {
            case "all":
                platformSet = EPlatform.getAll();
                break;
            case "android":
                platformSet.add(EPlatform.ANDROID);
                break;
            case "ios":
                platformSet.add(EPlatform.IOS);
                break;
            case "win":
                platformSet.add(EPlatform.WINDOWS);
                break;
            case "web":
                platformSet.add(EPlatform.WEB);
                break;
            default:
                System.err.println("unknown mode: " + commandLine.getOptionValue(PLATFORM_ARG));
            }
            builder.platform(platformSet);
        }

        if (commandLine.hasOption(UPSCALING_ALGO_ARG)) {
            builder.upScaleAlgorithm(
                    EScalingAlgorithm.getByName(commandLine.getOptionValue(UPSCALING_ALGO_ARG)));
        }

        if (commandLine.hasOption(DOWNSCALING_ALGO_ARG)) {
            builder.upScaleAlgorithm(
                    EScalingAlgorithm.getByName(commandLine.getOptionValue(DOWNSCALING_ALGO_ARG)));
        }

        if (commandLine.hasOption(ROUNDING_MODE_ARG)) {
            switch (commandLine.getOptionValue(ROUNDING_MODE_ARG)) {
            case "round":
                builder.scaleRoundingStragy(RoundingHandler.Strategy.ROUND_HALF_UP);
                break;
            case "ceil":
                builder.scaleRoundingStragy(RoundingHandler.Strategy.CEIL);
                break;
            case "floor":
                builder.scaleRoundingStragy(RoundingHandler.Strategy.FLOOR);
                break;
            default:
                System.err.println("unknown mode: " + commandLine.getOptionValue(ROUNDING_MODE_ARG));
            }
        }

        if (commandLine.hasOption(THREADS_ARG)) {
            builder.threadCount(Integer.valueOf(commandLine.getOptionValue(THREADS_ARG)));
        }

        builder.skipUpscaling(commandLine.hasOption("skipUpscaling"));
        builder.skipExistingFiles(commandLine.hasOption(SKIP_EXISTING_ARG));
        builder.includeAndroidLdpiTvdpi(commandLine.hasOption("androidIncludeLdpiTvdpi"));
        builder.verboseLog(commandLine.hasOption(VERBOSE_ARG));
        builder.haltOnError(commandLine.hasOption("haltOnError"));
        builder.createMipMapInsteadOfDrawableDir(commandLine.hasOption("androidMipmapInsteadOfDrawable"));
        builder.antiAliasing(commandLine.hasOption("antiAliasing"));
        builder.enablePngCrush(commandLine.hasOption("postProcessorPngCrush"));
        builder.postConvertWebp(commandLine.hasOption("postProcessorWebp"));
        builder.dryRun(commandLine.hasOption("dryRun"));
        builder.enableMozJpeg(commandLine.hasOption("postProcessorMozJpeg"));
        builder.keepUnoptimizedFilesPostProcessor(commandLine.hasOption("keepOriginalPostProcessedFiles"));
        builder.iosCreateImagesetFolders(commandLine.hasOption("iosCreateImagesetFolders"));
        builder.clearDirBeforeConvert(commandLine.hasOption("clean"));

        return builder.build();
    } catch (Exception e) {
        System.err.println("Could not parse args: " + e.getMessage());
    }
    return null;
}

From source file:com.blackducksoftware.tools.notifiers.jira.JiraIntegrationUtility.java

static int process(String[] args) {
    System.out.println("Jira Integration for Black Duck Suite");
    CommandLineParser parser = new DefaultParser();

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

    Option protexProjectNameOption = new Option(NotifierConstants.CL_PROTEX_PROJECT_NAME, true,
            "Name of Project (required)");
    protexProjectNameOption.setRequired(true);
    options.addOption(protexProjectNameOption);

    Option projectAliasOption = new Option(NotifierConstants.CL_JIRA_PROJECT_NAME, true,
            "Name of JIRA Project (optional)");
    projectAliasOption.setRequired(false);
    options.addOption(projectAliasOption);

    Option configFileOption = new Option("config", true, "Location of configuration file (required)");
    configFileOption.setRequired(true);/*w w w. j  av a2s .  co  m*/
    options.addOption(configFileOption);

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

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

        String projectName = null;
        File configFile = null;
        if (cmd.hasOption(NotifierConstants.CL_PROTEX_PROJECT_NAME)) {
            projectName = cmd.getOptionValue(NotifierConstants.CL_PROTEX_PROJECT_NAME);
            log.info("Project name: " + projectName);
        } else {
            log.error("Must specify project name!");
            help();
            return -1;
        }

        String jiraProjectName = null;
        if (cmd.hasOption(NotifierConstants.CL_JIRA_PROJECT_NAME)) {
            jiraProjectName = cmd.getOptionValue(NotifierConstants.CL_JIRA_PROJECT_NAME);
            log.info("JIRA Project name: " + projectName);
        }

        // Config File
        if (cmd.hasOption(NotifierConstants.CL_CONFIG)) {
            String configFilePath = cmd.getOptionValue(NotifierConstants.CL_CONFIG);
            log.info("Config file location: " + configFilePath);
            configFile = new File(configFilePath);
            if (!configFile.exists()) {
                log.error("Configuration file does not exist at location: " + configFile);
                return -1;
            }
        } else {
            log.error("Must specify configuration file!");
            help();
            return -1;
        }

        // Configuration manager
        JiraIntegrationUtilityConfig jiraConfig = new JiraIntegrationUtilityConfig(configFile);

        // Call the processor
        try {
            EmailContentMap keysOnlyContentMap = createKeysOnlyContentMap();
            JiraInfo jiraInfo = jiraConfig.getJiraInfo();
            JiraConnector jiraConnector = new JiraConnector(jiraInfo.getUrl(), jiraInfo.getAdminName(),
                    jiraInfo.getAdminPassword());
            IHandler notificationHandler = new JIRAHandler(jiraConfig, jiraConnector);
            ProtexServerWrapper<ProtexProjectPojo> psw = new ProtexServerWrapper<>(jiraConfig.getServerBean(),
                    jiraConfig, true);
            NotifierProcessor enp = new NotifierProcessor(jiraConfig, psw, notificationHandler,
                    keysOnlyContentMap, projectName, jiraProjectName);
            enp.process();
        } catch (Exception e) {
            log.error("Fatal error: " + e.getMessage());
        }

        log.info("Exiting.");
        return 0;

    } catch (ParseException e) {
        log.error("Unable to parse command line arguments: " + e.getMessage());
        help();
        return -1;
    }
}

From source file:com.google.cloud.iot.examples.DeviceRegistryExampleOptions.java

/** Construct an DeviceRegistryExampleOptions class from command line flags. */
public static DeviceRegistryExampleOptions fromFlags(String[] args) {
    Options options = new Options();
    // Required arguments
    options.addOption(Option.builder().type(String.class).longOpt("project_id").hasArg()
            .desc("GCP cloud project name.").required().build());
    options.addOption(Option.builder().type(String.class).longOpt("pubsub_topic").hasArg()
            .desc("Pub/Sub topic to create registry with, i.e. 'projects/project-id/topics/topic-id'")
            .required().build());//w  w w.  ja v  a2s  . c  om

    // Optional arguments.
    options.addOption(Option.builder().type(String.class).longOpt("ec_public_key_file").hasArg()
            .desc("Path to ES256 public key file.").build());
    options.addOption(Option.builder().type(String.class).longOpt("rsa_certificate_file").hasArg()
            .desc("Path to RS256 certificate file.").build());
    options.addOption(Option.builder().type(String.class).longOpt("cloud_region").hasArg()
            .desc("GCP cloud region.").build());

    CommandLineParser parser = new DefaultParser();
    CommandLine commandLine;
    try {
        commandLine = parser.parse(options, args);
        DeviceRegistryExampleOptions res = new DeviceRegistryExampleOptions();

        res.projectId = commandLine.getOptionValue("project_id");
        res.pubsubTopic = commandLine.getOptionValue("pubsub_topic");

        if (commandLine.hasOption("ec_public_key_file")) {
            res.ecPublicKeyFile = commandLine.getOptionValue("ec_public_key_file");
        }
        if (commandLine.hasOption("rsa_certificate_file")) {
            res.rsaCertificateFile = commandLine.getOptionValue("rsa_certificate_file");
        }
        if (commandLine.hasOption("cloud_region")) {
            res.cloudRegion = commandLine.getOptionValue("cloud_region");
        }
        return res;
    } catch (ParseException e) {
        System.err.println(e.getMessage());
        return null;
    }
}

From source file:com.google.gwt.site.markdown.MarkDown.java

private static CommandLine parseArgs(String[] args) throws ParseException {
    CommandLineParser parser = new DefaultParser();
    return parser.parse(OPTIONS, args);
}

From source file:edu.wright.daselab.linkgen.Generator.java

void run(String[] args) {
    CommandLineParser parser = new DefaultParser();
    Options optionList = new Options();
    Option configFile = Option.builder("c").longOpt("config").hasArg().required(false).desc(
            "Config File location. \n Optional - if config file is located in same location as that of jar.")
            .build();/*from   w  w  w . ja va2 s .c  om*/
    optionList.addOption(configFile);

    try {
        CommandLine line = parser.parse(optionList, args);
        if (line.hasOption("c")) {
            System.out.println("\t Custom config:" + line.getOptionValue("c"));
            ConfigurationLoader.CONFIG_FILE_LOCATION = line.getOptionValue("c");
        }
        Configuration config = ConfigurationLoader.getInstance().getConfig();
        ConfigurationParams.config = config;
        ConfigurationParams.checkStatusOnLoad();
    } catch (Exception exp) {
        usage(optionList);
        Monitor.safeExit(Error.CONFIG_FILE_LOAD_ERROR);
    }
    gensynth();
    Monitor.displayMessage("Generation Complete");
}

From source file:cli.CLI.java

public void parse() {
    CommandLineParser parser = new DefaultParser();

    CommandLine cmd = null;/*from w w  w .ja  v a2  s.c om*/
    try {
        cmd = parser.parse(_options, _args);

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

        if (cmd.hasOption("s")) {
            this._settings = cmd.getOptionValue("s");
        } else {
            System.out.println("Missing -s option. Please provide path to xml settings file.");
            help();
        }

        if (cmd.hasOption("d")) {
            this._job = cmd.getOptionValue("d");
        } else {
            System.out.println("Missing -d option. Please provide path to xml definition file.");
            help();
        }

        runJobManager(cmd);

    } catch (ParseException e) {
        help();
    }
}

From source file:esiptestbed.mudrod.ontology.process.LocalOntology.java

public static void main(String[] args) throws Exception {

    // boolean options
    Option helpOpt = new Option("h", "help", false, "show this help message");
    // argument options
    Option ontDirOpt = Option.builder(ONT_DIR).required(true).numberOfArgs(1).hasArg(true)
            .desc("A directory containing .owl files.").argName(ONT_DIR).build();

    // create the options
    Options options = new Options();
    options.addOption(helpOpt);//from  w ww .j a va  2 s.  c  o  m
    options.addOption(ontDirOpt);

    String ontDir;
    CommandLineParser parser = new DefaultParser();
    try {
        CommandLine line = parser.parse(options, args);

        if (line.hasOption(ONT_DIR)) {
            ontDir = line.getOptionValue(ONT_DIR).replace("\\", "/");
        } else {
            ontDir = LocalOntology.class.getClassLoader().getResource("ontology").getFile();
        }
        if (!ontDir.endsWith("/")) {
            ontDir += "/";
        }
    } catch (Exception e) {
        LOG.error("Error whilst processing main method of LocalOntology.", e);
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("LocalOntology: 'ontDir' argument is mandatory. ", options, true);
        return;
    }
    File fileDir = new File(ontDir);
    //Fail if the input is not a directory.
    if (fileDir.isDirectory()) {
        List<String> owlFiles = new ArrayList<>();
        for (File owlFile : fileDir.listFiles()) {
            owlFiles.add(owlFile.toString());
        }
        MudrodEngine mEngine = new MudrodEngine();
        Properties props = mEngine.loadConfig();
        Ontology ontology = new OntologyFactory(props).getOntology();
        //convert to correct iput for ontology loading.
        String[] owlArray = new String[owlFiles.size()];
        owlArray = owlFiles.toArray(owlArray);
        ontology.load(owlArray);

        String[] terms = new String[] { "Glacier ice" };
        //Demonstrate that we can do basic ontology heirarchy navigation and log output.
        for (Iterator<OntClass> i = getParser().rootClasses(getModel()); i.hasNext();) {

            //print Ontology Class Hierarchy
            OntClass c = i.next();
            renderHierarchy(System.out, c, new LinkedList<>(), 0);

            for (Iterator<OntClass> subClass = c.listSubClasses(true); subClass.hasNext();) {
                OntClass sub = subClass.next();
                //This means that the search term is present as an OntClass
                if (terms[0].equalsIgnoreCase(sub.getLabel(null))) {
                    //Add the search term(s) above to the term cache.
                    for (int j = 0; j < terms.length; j++) {
                        addSearchTerm(terms[j], sub);
                    }

                    //Query the ontology and return subclasses of the search term(s)
                    for (int k = 0; k < terms.length; k++) {
                        Iterator<String> iter = ontology.subclasses(terms[k]);
                        while (iter.hasNext()) {
                            LOG.info("Subclasses >> " + iter.next());
                        }
                    }

                    //print any synonymic relationships to demonstrate that we can 
                    //undertake synonym-based query expansion
                    for (int l = 0; l < terms.length; l++) {
                        Iterator<String> iter = ontology.synonyms(terms[l]);
                        while (iter.hasNext()) {
                            LOG.info("Synonym >> " + iter.next());
                        }
                    }
                }
            }
        }

        mEngine.end();
    }

}