Java CommandLine.getArgs方法代码示例

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private int transitionToStandby(final CommandLine cmd)
    throws IOException, ServiceFailedException {
  String[] argv = cmd.getArgs();
  if (argv.length != 1) {
    errOut.println("transitionToStandby: incorrect number of arguments");
    printUsage(errOut, "-transitionToStandby");
    return -1;
  }
  
  HAServiceTarget target = resolveTarget(argv[0]);
  if (!checkManualStateManagementOK(target)) {
    return -1;
  }
  HAServiceProtocol proto = target.getProxy(
      getConf(), 0);
  HAServiceProtocolHelper.transitionToStandby(proto, createReqInfo());
  return 0;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private int checkHealth(final CommandLine cmd)
    throws IOException, ServiceFailedException {
  String[] argv = cmd.getArgs();
  if (argv.length != 1) {
    errOut.println("checkHealth: incorrect number of arguments");
    printUsage(errOut, "-checkHealth");
    return -1;
  }
  HAServiceProtocol proto = resolveTarget(argv[0]).getProxy(
      getConf(), rpcTimeoutForChecks);
  try {
    HAServiceProtocolHelper.monitorHealth(proto, createReqInfo());
  } catch (HealthCheckFailedException e) {
    errOut.println("Health check failed: " + e.getLocalizedMessage());
    return -1;
  }
  return 0;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private static String getCommandName(String[] args) throws ParseException {

        Options opts = new Options();
        asList(CMOptions.HELP, CMOptions.VERSION, CMOptions.HOST, CMOptions.USER, CMOptions.PASSWORD).stream().map(
           new Function<Option, Option>() {

              @Override
              public Option apply(Option o) {
                Option c = CMOptions.clone(o);
                c.setRequired(false);
                return c;
              }
          }).forEach(o -> opts.addOption(o));

          CommandLine parser = new DefaultParser().parse(opts, args, true);
          if(parser.getArgs().length == 0) {
              throw new CMCommandLineException(format("Canmnot extract command name from arguments: '%s'.",
                        getArgsLogString(args)));
          }
          String commandName = parser.getArgs()[0];
          logger.debug(format("Command name '%s' extracted from command line '%s'.", commandName, getArgsLogString(args)));
          return commandName;
    }
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
public CliCommand parse(String[] cmdArgs) throws CliParseException {
    Parser parser = new PosixParser();
    CommandLine cl;
    try {
        cl = parser.parse(options, cmdArgs);
    } catch (ParseException ex) {
        throw new CliParseException(ex);
    }

    args = cl.getArgs();
    if (args.length < 2) {
        throw new CliParseException(getUsageStr());
    }

    return this;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
public CliCommand parse(String[] cmdArgs) throws CliParseException {
    Parser parser = new PosixParser();
    CommandLine cl;
    try {
        cl = parser.parse(options, cmdArgs);
    } catch (ParseException ex) {
        throw new CliParseException(ex);
    }
    args = cl.getArgs();
    if (args.length < 2) {
        throw new CliParseException(getUsageStr());
    }

    return this;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
public void extractTables(CommandLine line) throws ParseException {
    if (line.hasOption('b')) {
        if (line.getArgs().length != 0) {
            throw new ParseException("Filename specified with batch\nTry --help for help");
        }

        File pdfDirectory = new File(line.getOptionValue('b'));
        if (!pdfDirectory.isDirectory()) {
            throw new ParseException("Directory does not exist or is not a directory");
        }
        extractDirectoryTables(line, pdfDirectory);
        return;
    }

    if (line.getArgs().length != 1) {
        throw new ParseException("Need exactly one filename\nTry --help for help");
    }

    File pdfFile = new File(line.getArgs()[0]);
    if (!pdfFile.exists()) {
        throw new ParseException("File does not exist");
    }
    extractFileTables(line, pdfFile);
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
protected void processOptions(CommandLine cmd) {
  super.processOptions(cmd);

  String[] args = cmd.getArgs();
  if (args == null || args.length < 1) {
    usage();
    throw new RuntimeException("Incorrect Number of args.");
  }
  toRun = args[0];
  if (toRun.equalsIgnoreCase("search")) {
    if (args.length > 1) {
      keysDir = args[1];
    }
  }
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private int transitionToActive(final CommandLine cmd)
    throws IOException, ServiceFailedException {
  String[] argv = cmd.getArgs();
  if (argv.length != 1) {
    errOut.println("transitionToActive: incorrect number of arguments");
    printUsage(errOut, "-transitionToActive");
    return -1;
  }
  /*  returns true if other target node is active or some exception occurred 
      and forceActive was not set  */
  if(!cmd.hasOption(FORCEACTIVE)) {
    if(isOtherTargetNodeActive(argv[0], cmd.hasOption(FORCEACTIVE))) {
      return -1;
    }
  }
  HAServiceTarget target = resolveTarget(argv[0]);
  if (!checkManualStateManagementOK(target)) {
    return -1;
  }
  HAServiceProtocol proto = target.getProxy(
      getConf(), 0);
  HAServiceProtocolHelper.transitionToActive(proto, createReqInfo());
  return 0;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
protected void processOptions(CommandLine cmd) {
  super.processOptions(cmd);
  String[] args = cmd.getArgs();
  //get the class, run with the conf
  if (args.length < 1) {
    printUsage(this.getClass().getSimpleName() +
      " <general options> COMMAND [<COMMAND options>]", "General options:", "");
    printCommands();
    // Have to throw an exception here to stop the processing. Looks ugly but gets message across.
    throw new RuntimeException("Incorrect Number of args.");
  }
  toRun = args[0];
  otherArgs = Arrays.copyOfRange(args, 1, args.length);
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private int getServiceState(final CommandLine cmd)
    throws IOException, ServiceFailedException {
  String[] argv = cmd.getArgs();
  if (argv.length != 1) {
    errOut.println("getServiceState: incorrect number of arguments");
    printUsage(errOut, "-getServiceState");
    return -1;
  }

  HAServiceProtocol proto = resolveTarget(argv[0]).getProxy(
      getConf(), rpcTimeoutForChecks);
  out.println(proto.getServiceStatus().getState());
  return 0;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
public Set<TransferItem> find(final CommandLine input, final TerminalAction action, final Path remote) {
    final Local local = LocalFactory.get(input.getOptionValues(action.name())[1]);
    final Set<TransferItem> items = new HashSet<TransferItem>();
    items.add(this.resolve(remote, local));
    for(String arg : input.getArgs()) {
        items.add(this.resolve(remote, LocalFactory.get(arg)));
    }
    return items;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private int failover(CommandLine cmd)
    throws IOException, ServiceFailedException {
  boolean forceFence = cmd.hasOption(FORCEFENCE);
  boolean forceActive = cmd.hasOption(FORCEACTIVE);

  int numOpts = cmd.getOptions() == null ? 0 : cmd.getOptions().length;
  final String[] args = cmd.getArgs();

  if (numOpts > 3 || args.length != 2) {
    errOut.println("failover: incorrect arguments");
    printUsage(errOut, "-failover");
    return -1;
  }

  HAServiceTarget fromNode = resolveTarget(args[0]);
  HAServiceTarget toNode = resolveTarget(args[1]);
  
  // Check that auto-failover is consistently configured for both nodes.
  Preconditions.checkState(
      fromNode.isAutoFailoverEnabled() ==
        toNode.isAutoFailoverEnabled(),
        "Inconsistent auto-failover configs between %s and %s!",
        fromNode, toNode);
  
  if (fromNode.isAutoFailoverEnabled()) {
    if (forceFence || forceActive) {
      // -forceActive doesn't make sense with auto-HA, since, if the node
      // is not healthy, then its ZKFC will immediately quit the election
      // again the next time a health check runs.
      //
      // -forceFence doesn't seem to have any real use cases with auto-HA
      // so it isn't implemented.
      errOut.println(FORCEFENCE + " and " + FORCEACTIVE + " flags not " +
          "supported with auto-failover enabled.");
      return -1;
    }
    try {
      return gracefulFailoverThroughZKFCs(toNode);
    } catch (UnsupportedOperationException e){
      errOut.println("Failover command is not supported with " +
          "auto-failover enabled: " + e.getLocalizedMessage());
      return -1;
    }
  }
  
  FailoverController fc = new FailoverController(getConf(),
      requestSource);
  
  try {
    fc.failover(fromNode, toNode, forceFence, forceActive); 
    out.println("Failover from "+args[0]+" to "+args[1]+" successful");
  } catch (FailoverFailedException ffe) {
    errOut.println("Failover failed: " + ffe.getLocalizedMessage());
    return -1;
  }
  return 0;
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
private void processOptions(CommandLine line, Options opts)
  throws ParseException {
  if (line.hasOption("help") || line.hasOption('?')) {
    HelpFormatter formatter = new HelpFormatter();
    System.out.println("Protobuf IPC benchmark.");
    System.out.println();
    formatter.printHelp(100,
        "java ... PBRPCBenchmark [options]",
        "\nSupported options:", opts, "");
    return;
  }

  if (line.hasOption('s')) {
    serverThreads = Integer.parseInt(line.getOptionValue('s'));
  }
  if (line.hasOption('r')) {
    serverReaderThreads = Integer.parseInt(line.getOptionValue('r'));
  }
  if (line.hasOption('c')) {
    clientThreads = Integer.parseInt(line.getOptionValue('c'));
  }
  if (line.hasOption('t')) {
    secondsToRun = Integer.parseInt(line.getOptionValue('t'));
  }
  if (line.hasOption('m')) {
    msgSize = Integer.parseInt(line.getOptionValue('m'));
  }
  if (line.hasOption('p')) {
    port = Integer.parseInt(line.getOptionValue('p'));
  }
  if (line.hasOption('h')) {
    host = line.getOptionValue('h');
  }
  if (line.hasOption('e')) {
    String eng = line.getOptionValue('e');
    if ("protobuf".equals(eng)) {
      rpcEngine = ProtobufRpcEngine.class;
    } else if ("writable".equals(eng)) {
      rpcEngine = WritableRpcEngine.class;
    } else {
      throw new ParseException("invalid engine: " + eng);
    }
  }
  
  String[] remainingArgs = line.getArgs();
  if (remainingArgs.length != 0) {
    throw new ParseException("Extra arguments: " +
        Joiner.on(" ").join(remainingArgs));
  }
}
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException, InterruptedException, BrutException {

        // set verbosity default
        Verbosity verbosity = Verbosity.NORMAL;

        // cli parser
        CommandLineParser parser = new PosixParser();
        CommandLine commandLine = null;

        // load options
        _Options();

        try {
            commandLine = parser.parse(allOptions, args, false);
        } catch (ParseException ex) {
            System.err.println(ex.getMessage());
            usage(commandLine);
            return;
        }

        // check for verbose / quiet
        if (commandLine.hasOption("-v") || commandLine.hasOption("--verbose")) {
            verbosity = Verbosity.VERBOSE;
        } else if (commandLine.hasOption("-q") || commandLine.hasOption("--quiet")) {
            verbosity = Verbosity.QUIET;
        }
        setupLogging(verbosity);

        // check for advance mode
        if (commandLine.hasOption("advance") || commandLine.hasOption("advanced")) {
            setAdvanceMode(true);
        }

        // @todo use new ability of apache-commons-cli to check hasOption for non-prefixed items
        boolean cmdFound = false;
        for (String opt : commandLine.getArgs()) {
            if (opt.equalsIgnoreCase("d") || opt.equalsIgnoreCase("decode")) {
                cmdDecode(commandLine);
                cmdFound = true;
            } else if (opt.equalsIgnoreCase("b") || opt.equalsIgnoreCase("build")) {
                cmdBuild(commandLine);
                cmdFound = true;
            } else if (opt.equalsIgnoreCase("if") || opt.equalsIgnoreCase("install-framework")) {
                cmdInstallFramework(commandLine);
                cmdFound = true;
            } else if (opt.equalsIgnoreCase("publicize-resources")) {
                cmdPublicizeResources(commandLine);
                cmdFound = true;
            }
        }

        // if no commands ran, run the version / usage check.
        if (!cmdFound) {
            if (commandLine.hasOption("version") || commandLine.hasOption("version")) {
                _version();
            } else {
                usage(commandLine);
            }
        }
    }
 

import org.apache.commons.cli.CommandLine; //导入方法依赖的package包/类
@Override
public int run(String[] args) throws Exception {
  Options options = new Options();
  options.addOption("s", "start", true, "start key");
  options.addOption("e", "end", true, "end key");
  options.addOption("l", "limit", true, "number to print");

  GnuParser parser = new GnuParser();
  CommandLine cmd = null;
  try {
    cmd = parser.parse(options, args);
    if (cmd.getArgs().length != 0) {
      throw new ParseException("Command takes no arguments");
    }
  } catch (ParseException e) {
    System.err.println("Failed to parse command line " + e.getMessage());
    System.err.println();
    HelpFormatter formatter = new HelpFormatter();
    formatter.printHelp(getClass().getSimpleName(), options);
    System.exit(-1);
  }

  Table table = new HTable(getConf(), getTableName(getConf()));

  Scan scan = new Scan();
  scan.setBatch(10000);

  if (cmd.hasOption("s"))
    scan.setStartRow(Bytes.toBytesBinary(cmd.getOptionValue("s")));

  if (cmd.hasOption("e"))
    scan.setStopRow(Bytes.toBytesBinary(cmd.getOptionValue("e")));

  int limit = 0;
  if (cmd.hasOption("l"))
    limit = Integer.parseInt(cmd.getOptionValue("l"));
  else
    limit = 100;

  ResultScanner scanner = table.getScanner(scan);

  CINode node = new CINode();
  Result result = scanner.next();
  int count = 0;
  while (result != null && count++ < limit) {
    node = getCINode(result, node);
    System.out.printf("%s:%s:%012d:%s\n", Bytes.toStringBinary(node.key),
        Bytes.toStringBinary(node.prev), node.count, node.client);
    result = scanner.next();
  }
  scanner.close();
  table.close();

  return 0;
}