@Test public void withMissingOption() { OptionParser parser = new OptionParser(); parser.accepts("foo").withRequiredArg().withValuesSeparatedBy(','); OptionSet options = parser.parse(); // <-- no options whatsoever PropertySource<?> ps = new JOptCommandLinePropertySource(options); assertThat(ps.getProperty("foo"), nullValue()); }
public static void printHelper(OptionParser parser) { try { System.out.println("vjtop " + VERSION + " - java monitoring for the command-line"); System.out.println("Usage: vjtop.sh [options...] <PID>"); System.out.println(""); parser.printHelpOn(System.out); } catch (IOException ignored) { } }
public DownOperationOptions parseOptions(String[] operationArguments) { DownOperationOptions operationOptions = new DownOperationOptions(); OptionParser parser = new OptionParser(); parser.allowsUnrecognizedOptions(); OptionSpec<String> optionConflictStrategy = parser.acceptsAll(asList("C", "conflict-strategy")).withRequiredArg(); OptionSpec<Void> optionNoApply = parser.acceptsAll(asList("A", "no-apply")); OptionSet options = parser.parse(operationArguments); // --conflict-strategy=<strategy> if (options.has(optionConflictStrategy)) { String conflictStrategyStr = options.valueOf(optionConflictStrategy).toUpperCase(); operationOptions.setConflictStrategy(DownConflictStrategy.valueOf(conflictStrategyStr)); } // --no-apply if (options.has(optionNoApply)) { operationOptions.setApplyChanges(false); } return operationOptions; }
private static void setupParser() { parser = new OptionParser(); parser.accepts("help", "Print usage information"); parser.accepts("cluster", "Path to cluster xml") .withRequiredArg() .describedAs("cluster.xml"); parser.accepts("stores", "Path to store definition xml") .withRequiredArg() .describedAs("stores.xml"); }
public static OptionParser getParser() { OptionParser parser = new OptionParser(); parser.acceptsAll(Arrays.asList("bdb"), "Store level BDB folder") .withRequiredArg() .ofType(String.class) .describedAs("input-file-or-folder"); parser.acceptsAll(Arrays.asList("o", "output"), "Output folder of text dump") .withRequiredArg() .ofType(String.class) .describedAs("output-folder"); return parser; }
private static OptionParser setupParser() { OptionParser parser = new OptionParser(); parser.accepts("help", "Print usage information").withOptionalArg(); parser.acceptsAll(Arrays.asList("id", "nodeId"), "expected node Id") .withRequiredArg() .describedAs("expected node Id") .ofType(String.class); parser.acceptsAll(Arrays.asList("path", "clusterPath"), "clusterPath") .withRequiredArg() .describedAs("clusterPath") .ofType(String.class); return parser; }
List<String> args) throws Exception { OptionParser p = new OptionParser(); OptionSpec<String> keyOption = p.accepts("key", "Metadata key") .withOptionalArg() .ofType(String.class); OptionSet opts = p.parse(args.toArray(new String[0])); String keyName = keyOption.value(opts); List<String> nargs = (List<String>)opts.nonOptionArguments(); if (nargs.size() != 1) { err.println("Expected 1 arg: input_file"); p.printHelpOn(err); return 1;
try { parser = setupParser(); options = parser.parse(args); } catch(OptionException oe) { parser.printHelpOn(System.out); printUsageAndDie("Exception when parsing arguments : " + oe.getMessage()); return; if(options.has("help")) { printUsage(); return; if(!options.hasArgument("url") || !options.hasArgument("stores") || !options.hasArgument("keyfile")) { printUsageAndDie("Missing a required argument.");
public static void main(String... args) throws Exception { final OptionParser parser = new OptionParser(); final OptionSpec<Void> help = parser.accepts("help").forHelp(); final OptionSpec<Double> wgsLongitudeOpt = parser.acceptsAll(Arrays.asList("longitude")) .withRequiredArg().ofType(Double.class).required().describedAs("The WGS Longitude"); final OptionSpec<Double> wgsLatitudeOpt = parser.acceptsAll(Arrays.asList("latitude")) .withRequiredArg().ofType(Double.class).required().describedAs("The WGS Latitude"); OptionSet options = null; try { options = parser.parse(args); } catch (final OptionException e) { System.out.println(e.getMessage()); parser.printHelpOn(System.out); throw e; } if (options.has(help)) { parser.printHelpOn(System.out); return; } UTM fromWGS = UTM.fromWGS84(wgsLatitudeOpt.value(options), wgsLongitudeOpt.value(options)); System.out.println(fromWGS.toString()); } }
public static void main(String[] args) throws Exception { OptionParser parser = new OptionParser(); parser.accepts("help", "print usage information"); parser.acceptsAll(asList("r", "reads"), "Enable reads."); parser.acceptsAll(asList("w", "writes"), "Enable writes."); parser.acceptsAll(asList("d", "deletes"), "Enable deletes."); parser.accepts("table", "Table name").withRequiredArg(); parser.accepts("db", "Database name").withRequiredArg(); parser.acceptsAll(asList("u", "user"), "DB username.").withRequiredArg(); parser.acceptsAll(asList("P", "password"), "DB password").withRequiredArg(); parser.acceptsAll(asList("p", "port"), "DB port").withRequiredArg(); parser.acceptsAll(asList("h", "host"), "DB host").withRequiredArg(); parser.accepts("requests").withRequiredArg().ofType(Integer.class); parser.accepts("request-file").withRequiredArg(); parser.accepts("threads").withRequiredArg().ofType(Integer.class); OptionSet options = parser.parse(args); if(options.has("help")) { parser.printHelpOn(System.out); System.exit(0); String table = (String) options.valueOf("table"); int port = CmdUtils.valueOf(options, "port", 3306); String database = (String) options.valueOf("db"); String jdbcUrl = "jdbc:mysql://" + host + ":" + port + "/" + database; String user = CmdUtils.valueOf(options, "user", "root");
@SuppressWarnings("unchecked") public static void main(String[] args) throws IOException { OptionParser parser = new OptionParser(); parser.accepts("k", "key size").withRequiredArg().ofType(Integer.class); parser.accepts("v", "value size").withRequiredArg().ofType(Integer.class); parser.accepts("p", "prefix").withRequiredArg(); OptionSet options = parser.parse(args); List<String> nonOptions = (List<String>) options.nonOptionArguments(); if(nonOptions.size() != 3) { printUsage(System.err, parser); } String url = nonOptions.get(0); String storeName = nonOptions.get(1); int requests = Integer.parseInt(nonOptions.get(2)); int keySize = CmdUtils.valueOf(options, "k", 128); int valueSize = CmdUtils.valueOf(options, "v", 256); int workers = CmdUtils.valueOf(options, "threads", MAX_WORKERS); String postfix = (String) (options.has("p") ? options.valueOf("p") : null); RemoteDataGenerator rdg = new RemoteDataGenerator(url, storeName, workers); rdg.generateData(requests, keySize, valueSize, postfix); } }
public static void main(final String[] args) throws Exception { final OptionParser parser = new OptionParser(); final OptionSpec<String> scriptDirectory = parser .acceptsAll(Arrays.asList("s", "script"), "Directory of update scripts.").withRequiredArg() .describedAs("script").ofType(String.class); final OptionSpec<Void> updateOption = parser.acceptsAll(Arrays.asList("u", "update"), "Will update if necessary"); final Props props = AzkabanServer.loadProps(args, parser); if (props == null) { logger.error("Properties not found. Need it to connect to the db."); logger.error("Exiting..."); return; } final OptionSet options = parser.parse(args); boolean updateDB = false; if (options.has(updateOption)) { updateDB = true; } else { logger.info("Running DatabaseUpdater in test mode"); } String scriptDir = "sql"; if (options.has(scriptDirectory)) { scriptDir = options.valueOf(scriptDirectory); } runDatabaseUpdater(props, scriptDir, updateDB); }
final OptionParser parser = new OptionParser(); parser.accepts("help", "show this help").forHelp(); parser.acceptsAll(Arrays.asList("s", "brief"), "only show validation status (OK/NOT OK)"); parser.acceptsAll(Arrays.asList("q", "quiet"), "no output; exit with the relevant return code (see below)"); parser.accepts("syntax", "check the syntax of schema(s) given as argument(s)"); parser.accepts("fakeroot", "pretend that the current directory is absolute URI \"uri\"") .withRequiredArg(); parser.formatHelpWith(HELP); optionSet = parser.parse(args); } catch (OptionException e) { System.err.println("unrecognized option(s): " + CustomHelpFormatter.OPTIONS_JOINER.join(e.options())); parser.printHelpOn(System.err); System.exit(CMD_ERROR.get()); throw new IllegalStateException("WTF??"); if (optionSet.has("help")) { parser.printHelpOn(System.out); System.exit(ALL_OK.get()); if (optionSet.has("s") && optionSet.has("q")) { System.err.println("cannot specify both \"--brief\" and " + "\"--quiet\""); parser.printHelpOn(System.err);
private Configure analyzeConfigure(String[] args) { final OptionParser parser = new OptionParser(); parser.accepts("pid").withRequiredArg().ofType(int.class).required(); parser.accepts("target").withOptionalArg().ofType(String.class); parser.accepts("multi").withOptionalArg().ofType(int.class); parser.accepts("core").withOptionalArg().ofType(String.class); parser.accepts("agent").withOptionalArg().ofType(String.class); final OptionSet os = parser.parse(args); final Configure configure = new Configure(); if (os.has("target")) { final String[] strSplit = ((String) os.valueOf("target")).split(":"); configure.setTargetIp(strSplit[0]); configure.setTargetPort(Integer.valueOf(strSplit[1])); } configure.setJavaPid((Integer) os.valueOf("pid")); configure.setGreysAgent((String) os.valueOf("agent")); configure.setGreysCore((String) os.valueOf("core")); return configure; }
public void run(String[] args) throws Exception { OptionParser parser = new OptionParser(); parser.formatHelpWith(new OptionFormatter(label())); OptionSpec<String> optClassPath = parser.accepts("cp", "Additional classpath entries, where to look for the referenced classes.") .withRequiredArg().ofType(String.class).describedAs("classpath").withValuesSeparatedBy(getProperty("path.separator")); OptionSpec<String> optClasses = parser.nonOptions("Class names to work on."); OptionSet set = parser.parse(args); classes = set.valuesOf(optClasses); if (classes.isEmpty()) { System.err.println("Need class name(s) as the arguments."); System.err.println(); parser.printHelpOn(System.err); return; if (set.has(optClassPath)) { ClassUtils.addClasspathEntries(optClassPath.values(set)); parser.printHelpOn(System.err); return;
@Override public UpdateOperationOptions parseOptions(String[] operationArgs) throws Exception { UpdateOperationOptions operationOptions = new UpdateOperationOptions(); OptionParser parser = new OptionParser(); OptionSpec<Void> optionSnapshots = parser.acceptsAll(asList("s", "snapshot", "snapshots")); OptionSpec<String> optionApiEndpoint = parser.acceptsAll(asList("a", "api-endpoint")).withRequiredArg(); OptionSet options = parser.parse(operationArgs); // Action List<?> nonOptionArgs = options.nonOptionArguments(); if (nonOptionArgs.size() == 0) { throw new Exception("Invalid syntax, please specify an action (check)."); } // <action> String actionStr = nonOptionArgs.get(0).toString(); UpdateOperationAction action = parseAction(actionStr); operationOptions.setAction(action); // --snapshots operationOptions.setSnapshots(options.has(optionSnapshots)); // --api-endpoint if (options.has(optionApiEndpoint)) { operationOptions.setApiEndpoint(options.valueOf(optionApiEndpoint)); } return operationOptions; }
ProxyOptions(final String[] args) { final OptionParser parser = new OptionParser(); final OptionSpec<Void> help = parser.acceptsAll(Arrays.asList("h", "help"), "Print help") .forHelp(); final OptionSpec<Integer> port = parser.acceptsAll(Arrays.asList("p", "port"), "Specify the bind port to be used. The configuration bind port will be ignored.") .withRequiredArg().ofType(Integer.class); final OptionSet set = parser.parse(args); this.help = set.has(help); this.port = port.value(set); if (this.help) { try { parser.printHelpOn(System.out); } catch (final IOException e) { logger.error("Could not print help", e); } } }
@Override public GenlinkOperationOptions parseOptions(String[] operationArgs) { GenlinkOperationOptions operationOptions = new GenlinkOperationOptions(); OptionParser parser = new OptionParser(); OptionSpec<Void> optionMachineReadable = parser.acceptsAll(asList("m", "machine-readable")); OptionSpec<Void> optionShort = parser.acceptsAll(asList("s", "short")); parser.allowsUnrecognizedOptions(); OptionSet options = parser.parse(operationArgs); // --machine-readable, -m machineReadableOutput = options.has(optionMachineReadable); // --short, -s operationOptions.setShortUrl(options.has(optionShort)); return operationOptions; }
private static OptionSet getValidOptions(String[] args) { OptionSet options = null; try { options = parser.parse(args); } catch(OptionException oe) { printUsageAndDie("Exception when parsing arguments : " + oe.getMessage()); } if(options.has("help")) { printUsage(); System.exit(0); } Set<String> missing = CmdUtils.missing(options, "url", "final-cluster"); if(missing.size() > 0) { printUsageAndDie("Missing required arguments: " + Joiner.on(", ").join(missing)); } return options; }
/** * Adds OPT_FORMAT option to OptionParser, with one argument. * * @param parser OptionParser to be modified * @param required Tells if this option is required or optional */ public static void acceptsFormat(OptionParser parser) { parser.accepts(OPT_FORMAT, "format of key or entry, could be hex, json or binary") .withRequiredArg() .describedAs("hex | json | binary") .ofType(String.class); }