if(options.has("help")) { printUsage(); return; if(!options.hasArgument("url") || !options.hasArgument("stores") || !options.hasArgument("keyfile")) { printUsageAndDie("Missing a required argument."); return; boolean deleteAllVersions = options.has("delete-all-versions"); System.out.println("New Delete All versions value " + deleteAllVersions); String url = (String) options.valueOf("url"); String keyFile = (String) options.valueOf("keyfile"); keyFile.replace("~", System.getProperty("user.home")); if(options.hasArgument("zone")) { zoneId = ((Integer) options.valueOf("zone")).intValue(); int qps = ((Integer) options.valueOf("qps")).intValue(); int nodeid = ((Integer) options.valueOf("nodeid")).intValue(); adminUrl = (String) options.valueOf("admin-url"); if(options.hasArgument("stores")) { @SuppressWarnings("unchecked") List<String> list = (List<String>) options.valuesOf("stores"); stores = list;
@Override public int execute(String[] operationArgs) throws Exception { OptionParser parser = new OptionParser(); OptionSet options = parser.parse(operationArgs); // Files List<?> nonOptionArgs = options.nonOptionArguments(); if (nonOptionArgs.size() > 0) { String debugCommand = nonOptionArgs.get(0).toString(); List<?> newNonOptionArgs = nonOptionArgs.subList(1, nonOptionArgs.size()); if ("decrypt".equals(debugCommand)) { runDebugCommand(newNonOptionArgs); } } throw new Exception("Invalid syntax. No command given or command unknown."); }
private static boolean extractBoolOption(OptionSet options, String optionName) { boolean optionValue = false; if(options.has(optionName)) { if(options.hasArgument(optionName)) { optionValue = (Boolean) options.valueOf(optionName); } else { optionValue = true; } } return optionValue; }
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");
if(optionSet.hasArgument("help")) { if(!optionSet.hasArgument("url")) { printUsage("Missing required 'url' argument.", parser); if(!optionSet.hasArgument("store")) { printUsage("Missing required 'store' argument.", parser); if(!optionSet.has("bad-key-file-in")) { printUsage("Missing required 'bad-key-file-in' argument.", parser); if(!optionSet.has("bad-key-file-out")) { printUsage("Missing required 'bad-key-file-out' argument.", parser); options.url = (String) optionSet.valueOf("url"); options.storeName = (String) optionSet.valueOf("store"); options.badKeyFileIn = (String) optionSet.valueOf("bad-key-file-in"); options.badKeyFileOut = (String) optionSet.valueOf("bad-key-file-out"); if(optionSet.has("orphan-format")) { options.badKeyFileInOrphanFormat = true; if(optionSet.has("parallelism")) { options.parallelism = (Integer) optionSet.valueOf("parallelism"); if(optionSet.has("progress-period-ops")) { options.progressPeriodOps = (Long) optionSet.valueOf("progress-period-ops"); if(optionSet.has("per-server-qps-limit")) { options.perServerQPSLimit = (Long) optionSet.valueOf("per-server-qps-limit");
LogOperationOptions operationOptions = new LogOperationOptions(); OptionParser parser = new OptionParser(); parser.allowsUnrecognizedOptions(); OptionSpec<Integer> optionMaxDatabaseVersionCountStr = parser.acceptsAll(asList("n", "database-count")).withRequiredArg().ofType(Integer.class); OptionSpec<Integer> optionStartDatabaseVersionIndexStr = parser.acceptsAll(asList("s", "database-start")).withRequiredArg().ofType(Integer.class); OptionSpec<Integer> optionMaxFileHistoryCountStr = parser.acceptsAll(asList("f", "file-count")).withRequiredArg().ofType(Integer.class); OptionSpec<Void> optionExcludeEmpty = parser.acceptsAll(asList("x", "exclude-empty")); excludeEmpty = options.has(optionExcludeEmpty); if (options.has(optionMaxDatabaseVersionCountStr)) { operationOptions.setMaxDatabaseVersionCount(options.valueOf(optionMaxDatabaseVersionCountStr)); if (options.has(optionStartDatabaseVersionIndexStr)) { operationOptions.setStartDatabaseVersionIndex(options.valueOf(optionStartDatabaseVersionIndexStr)); if (options.has(optionMaxFileHistoryCountStr)) { operationOptions.setMaxFileHistoryCount(options.valueOf(optionMaxFileHistoryCountStr));
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()); } }
@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); } }
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 static void main(final String... args) throws IOException, ProcessingException .withRequiredArg(); if (optionSet.has("help")) { if (optionSet.has("s") && optionSet.has("q")) { System.err.println("cannot specify both \"--brief\" and " + "\"--quiet\""); if (optionSet.has("fakeroot")) fakeRoot = (String) optionSet.valueOf("fakeroot"); isSyntax = optionSet.has("syntax"); requiredArgs = isSyntax ? 1 : 2; = (List<String>) optionSet.nonOptionArguments(); files.add(new File(target).getCanonicalFile()); if (optionSet.has("brief")) reporter = Reporters.BRIEF; else if (optionSet.has("quiet")) { System.out.close(); System.err.close();
OptionSet options = parser.parse(args); if(options.has(AdminParserUtils.OPT_HELP)) { printHelp(System.out); return; if(options.has(AdminParserUtils.OPT_HEX)) { keyType = AdminParserUtils.OPT_HEX; keyStrings = (List<String>) options.valuesOf(AdminParserUtils.OPT_HEX); } else if(options.has(AdminParserUtils.OPT_JSON)) { keyType = AdminParserUtils.OPT_JSON; keyStrings = (List<String>) options.valuesOf(AdminParserUtils.OPT_JSON); throw new VoldemortException("Key type OPT_JSON not supported."); storeName = (String) options.valueOf(AdminParserUtils.OPT_STORE); url = (String) options.valueOf(AdminParserUtils.OPT_URL);
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); }
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."); try { OptionSet set = parser.parse(args); classes = set.valuesOf(optClasses); if (classes.isEmpty()) { System.err.println("Need class name(s) as the arguments."); if (set.has(optClassPath)) { ClassUtils.addClasspathEntries(optClassPath.values(set));
@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, "current-cluster", "current-stores"); if(missing.size() > 0) { printUsageAndDie("Missing required arguments: " + Joiner.on(", ").join(missing)); } if(options.has("final-stores") && !options.has("interim-cluster")) { printUsageAndDie("final-stores specified, but interim-cluster not specified."); } return options; }
OptionParser parser = new OptionParser(); parser.accepts("async-scan-interval", "Time interval (in milliseconds) at which the AsyncRecoveryFailureDetector checks for recovered nodes. Default: " + failureDetectorConfig.getAsyncRecoveryInterval()) .withRequiredArg() .ofType(Long.class); parser.accepts("bannage-period", "Time period (in milliseconds) for which a failed node is marked unavailable for the BannagePeriodFailureDetector. Default: " + failureDetectorConfig.getBannagePeriod()) .withRequiredArg() .ofType(Long.class); parser.accepts("threshold-interval", "Time interval (in milliseconds) for which a node is marked unavailable by the ThresholdFailureDetector for having fallen under the threshold for failures for the period, after which it is considered available. Default: " + failureDetectorConfig.getThresholdInterval()) .withRequiredArg() .ofType(Long.class); parser.accepts("help", "This help"); OptionSet options = parser.parse(args); if(options.has("help")) printUsage(parser);