Ejemplo n.º 1
0
  @Test
  public void testGetOptionParser() throws Exception {
    OptionParser optionParser = Main.getOptionParser();

    String tmpDir = systemTempDir().toString();

    OptionSet optionSet =
        optionParser.parse(
            "-f",
            "/tmp/dummy",
            "-s",
            "9908:976098897",
            "-r",
            "9908:810017902",
            "-u",
            "https://ap.unit4.com",
            "-m",
            "as2",
            "-e",
            tmpDir);
    assertTrue(optionSet.has("u"));
    assertTrue(optionSet.has("f"));
    assertTrue(optionSet.has("e"));
    Object e = optionSet.valueOf("e");
    assertNotNull(e);
    assertTrue(e instanceof File);
    File f = (File) e;
    assertEquals(f, new File(tmpDir));
  }
  protected void main(OptionParser parser, OptionSet options) {
    int flags = 0;
    if (options.has("o2")) flags |= QBImporter.TEXTUREPLANES;
    if (options.has("s")) flags |= QBImporter.SQUARETEXTURE;
    if (options.has("t")) flags |= QBImporter.MERGETEXTURES;
    if (options.has("r")) flags |= QBImporter.SCALEMC;

    File[] input = options.valuesOf("input").toArray(new File[0]);
    File[] outDir = new File[input.length];
    if (options.has("out")) {
      File output = (File) options.valueOf("out");
      if (output.isFile()) throw new RuntimeException("Output Path is not a directory");
      if (!output.exists()) output.mkdirs();

      for (int i = 0; i < input.length; i++) outDir[i] = output;
    } else {
      for (int i = 0; i < input.length; i++)
        outDir[i] = input[i].isDirectory() ? input[i] : input[i].getParentFile();
    }

    for (int i = 0; i < input.length; i++) {
      File file = input[i];
      if (file.isDirectory()) {
        for (File file2 : file.listFiles())
          if (file2.getName().endsWith(".qb")) convert(file2, outDir[i], flags);
      } else convert(file, outDir[i], flags);
    }
  }
Ejemplo n.º 3
0
  @Test
  public void supportsPosixlyCorrectBehavior() {
    OptionParser parser = new OptionParser("i:j::k");
    String[] arguments = {
      "-ibar", "-i", "junk", "xyz", "-jixnay", "foo", "-k", "blah", "--", "bah"
    };

    OptionSet options = parser.parse(arguments);

    assertTrue(options.has("i"));
    assertTrue(options.has("j"));
    assertTrue(options.has("k"));
    assertEquals(asList("bar", "junk"), options.valuesOf("i"));
    assertEquals(singletonList("ixnay"), options.valuesOf("j"));
    assertEquals(asList("xyz", "foo", "blah", "bah"), options.nonOptionArguments());

    parser.posixlyCorrect(true);
    options = parser.parse(arguments);

    assertTrue(options.has("i"));
    assertFalse(options.has("j"));
    assertFalse(options.has("k"));
    assertEquals(asList("bar", "junk"), options.valuesOf("i"));
    assertEquals(emptyList(), options.valuesOf("j"));
    assertEquals(
        asList("xyz", "-jixnay", "foo", "-k", "blah", "--", "bah"), options.nonOptionArguments());
  }
Ejemplo n.º 4
0
 private static long getCreationTimeSeconds() {
   long creationTimeSeconds = 0;
   if (options.has(unixtimeFlag)) {
     creationTimeSeconds = unixtimeFlag.value(options);
   } else if (options.has(dateFlag)) {
     creationTimeSeconds = dateFlag.value(options).getTime() / 1000;
   }
   return creationTimeSeconds;
 }
Ejemplo n.º 5
0
 private static void addKey() {
   ECKey key;
   long creationTimeSeconds = getCreationTimeSeconds();
   if (options.has("privkey")) {
     String data = (String) options.valueOf("privkey");
     if (data.startsWith("5J") || data.startsWith("5H") || data.startsWith("5K")) {
       DumpedPrivateKey dpk;
       try {
         dpk = new DumpedPrivateKey(params, data);
       } catch (AddressFormatException e) {
         System.err.println("Could not parse dumped private key " + data);
         return;
       }
       key = dpk.getKey();
     } else {
       byte[] decode = Utils.parseAsHexOrBase58(data);
       if (decode == null) {
         System.err.println("Could not understand --privkey as either hex or base58: " + data);
         return;
       }
       key = new ECKey(new BigInteger(1, decode));
     }
     if (options.has("pubkey")) {
       // Give the user a hint.
       System.out.println("You don't have to specify --pubkey when a private key is supplied.");
     }
     key.setCreationTimeSeconds(creationTimeSeconds);
   } else if (options.has("pubkey")) {
     byte[] pubkey = Utils.parseAsHexOrBase58((String) options.valueOf("pubkey"));
     key = new ECKey(null, pubkey);
     key.setCreationTimeSeconds(creationTimeSeconds);
   } else {
     // Freshly generated key.
     key = new ECKey();
     if (creationTimeSeconds > 0) key.setCreationTimeSeconds(creationTimeSeconds);
   }
   if (wallet.findKeyFromPubKey(key.getPubKey()) != null) {
     System.err.println("That key already exists in this wallet.");
     return;
   }
   try {
     if (wallet.isEncrypted()) {
       if (password == null || !wallet.checkPassword(password)) {
         System.err.println("The password is incorrect.");
         return;
       }
       key = key.encrypt(wallet.getKeyCrypter(), wallet.getKeyCrypter().deriveKey(password));
     }
     wallet.addKey(key);
   } catch (KeyCrypterException kce) {
     System.err.println(
         "There was an encryption related error when adding the key. The error was '"
             + kce.getMessage()
             + "'.");
   }
   System.out.println(key.toAddress(params) + " " + key);
 }
Ejemplo n.º 6
0
  private void unschedule(String[] args) throws Exception {
    String[] ONE_REQUIRED = {OPT_RESOURCEID, OPT_GROUPID};

    OptionParser p = getOptionParser();

    p.accepts(OPT_RESOURCEID, "The id of the resource to unschedule from maintenance")
        .withRequiredArg()
        .ofType(Integer.class);

    p.accepts(OPT_GROUPID, "The id of the group to unschedule from maintenance")
        .withRequiredArg()
        .ofType(Integer.class);

    OptionSet options = getOptions(p, args);

    int criteria = 0;
    for (String opt : ONE_REQUIRED) {
      if (options.has(opt)) {
        criteria++;
      }
    }

    if (criteria == 0) {
      System.err.println("One of " + Arrays.toString(ONE_REQUIRED) + " is required.");
      System.exit(-1);
    } else if (criteria > 1) {
      System.err.println("Only one of " + Arrays.toString(ONE_REQUIRED) + " may be specified");
      System.exit(-1);
    }

    HQApi api = getApi(options);
    MaintenanceApi maintenanceApi = api.getMaintenanceApi();
    StatusResponse response = null;
    Integer id = null;

    if (options.has(OPT_GROUPID)) {
      id = (Integer) getRequired(options, OPT_GROUPID);
      response = maintenanceApi.unschedule(id);
    } else if (options.has(OPT_RESOURCEID)) {
      id = (Integer) getRequired(options, OPT_RESOURCEID);
      ResourceResponse resourceResponse = api.getResourceApi().getResource(id, false, false);
      checkSuccess(resourceResponse);
      response = maintenanceApi.unschedule(resourceResponse.getResource());
    }

    checkSuccess(response);

    if (options.has(OPT_GROUPID)) {
      System.out.println("Maintenance for group " + id + " unscheduled.");
    } else {
      System.out.println("Maintenance for resource " + id + " unscheduled.");
    }
  }
Ejemplo n.º 7
0
  @SuppressWarnings("unchecked")
  public static void main(String[] args) throws Exception {
    OptionParser parser = new OptionParser();

    parser.accepts("native", "use native admin client");
    parser.accepts("f", "execute fetch operation");
    parser.accepts("fu", "fetch and update").withRequiredArg().ofType(Integer.class);
    parser
        .accepts("n", "node id")
        .withRequiredArg()
        .ofType(Integer.class)
        .withValuesSeparatedBy(',');
    parser
        .accepts("p", "partition id")
        .withRequiredArg()
        .ofType(Integer.class)
        .withValuesSeparatedBy(',');
    OptionSet options = parser.parse(args);

    List<String> nonOptions = (List<String>) options.nonOptionArguments();

    if (args.length < 2) {
      System.out.println(usageStr);
      return;
    }

    String bootstrapUrl = nonOptions.get(0);
    String storeName = nonOptions.get(1);

    if (!options.has("p") && !options.has("n")) {
      printUsage(
          System.err,
          parser,
          "One or more node and/or one or more partition has" + " to be specified");
    }

    AdminTest adminTest;

    adminTest = new AdminTest(bootstrapUrl, storeName);

    SetMultimap<Integer, Integer> nodePartitions =
        adminTest.getNodePartitions(
            options.has("n") ? options.valuesOf("n") : null,
            options.has("p") ? options.valuesOf("p") : null);

    if (options.has("f")) adminTest.testFetch(nodePartitions);
    if (options.has("fu"))
      adminTest.testFetchAndUpdate(nodePartitions, (Integer) options.valueOf("fu"));
  }
Ejemplo n.º 8
0
 private String managePermissions(IMessage message, OptionSet optionSet) {
   List<String> nonOptions = optionSet.valuesOf(permNonOptionSpec);
   if (optionSet.has("?") || nonOptions.size() < 2) {
     return null;
   }
   String permName = nonOptions.get(0).toLowerCase();
   String action = nonOptions.get(1).toLowerCase();
   Optional<Permission> permission = permissionService.findPermissionByName(permName);
   List<String> args = nonOptions.subList(2, nonOptions.size());
   if (action.equals("list")) {
     return listPermissions(message, permName, args);
   } else if (action.equals("evict")) {
     permissionService.evict();
     return "OK";
   } else if (!permission.isPresent()) {
     return "Not a valid permission name";
   } else if (action.equals("allow")) {
     return editPermission(Operation.ALLOW, message, permission.get(), args);
   } else if (action.equals("deny")) {
     return editPermission(Operation.DENY, message, permission.get(), args);
   } else if (action.equals("reset")) {
     return editPermission(Operation.RESET, message, permission.get(), args);
   }
   return "Invalid operation! Check details with `.perm -?`";
 }
Ejemplo n.º 9
0
  public static void main(String[] args) throws Exception {

    OptionParser parser = new OptionParser();
    parser
        .accepts("client-zone-id", "client zone id for zone routing")
        .withRequiredArg()
        .describedAs("zone-id")
        .ofType(Integer.class);
    OptionSet options = parser.parse(args);

    List<String> nonOptions = options.nonOptionArguments();
    if (nonOptions.size() < 2 || nonOptions.size() > 3) {
      System.err.println(
          "Usage: java VoldemortClientShell store_name bootstrap_url [command_file] [options]");
      parser.printHelpOn(System.err);
      System.exit(-1);
    }

    String storeName = nonOptions.get(0);
    String bootstrapUrl = nonOptions.get(1);

    String commandsFileName = "";
    BufferedReader fileReader = null;
    BufferedReader inputReader = null;
    try {
      if (nonOptions.size() == 3) {
        commandsFileName = nonOptions.get(2);
        fileReader = new BufferedReader(new FileReader(commandsFileName));
      }

      inputReader = new BufferedReader(new InputStreamReader(System.in));
    } catch (IOException e) {
      Utils.croak("Failure to open input stream: " + e.getMessage());
    }

    ClientConfig clientConfig =
        new ClientConfig()
            .setBootstrapUrls(bootstrapUrl)
            .setRequestFormatType(RequestFormatType.VOLDEMORT_V3);

    if (options.has("client-zone-id")) {
      clientConfig.setClientZoneId((Integer) options.valueOf("client-zone-id"));
    }

    StoreClientFactory factory = new SocketStoreClientFactory(clientConfig);

    try {
      client = (DefaultStoreClient<Object, Object>) factory.getStoreClient(storeName);
    } catch (Exception e) {
      Utils.croak("Could not connect to server: " + e.getMessage());
    }

    System.out.println("Established connection to " + storeName + " via " + bootstrapUrl);
    System.out.print(PROMPT);
    if (fileReader != null) {
      processCommands(factory, fileReader, true);
      fileReader.close();
    }
    processCommands(factory, inputReader, false);
  }
  @Test
  public void allowsDifferentFormsOfPairingArgumentWithOption() {
    OptionParser parser = new OptionParser();
    parser.accepts("count").withRequiredArg();
    parser.accepts("level").withOptionalArg();

    OptionSet options = parser.parse("--count", "4", "--level=3");

    assertTrue(options.has("count"));
    assertTrue(options.hasArgument("count"));
    assertEquals("4", options.valueOf("count"));

    assertTrue(options.has("level"));
    assertTrue(options.hasArgument("level"));
    assertEquals("3", options.valueOf("level"));
  }
Ejemplo n.º 11
0
 private static void send(PaymentSession session) {
   try {
     System.out.println("Payment Request");
     System.out.println("Amount: " + session.getValue().doubleValue() / 100000 + "mDOGE");
     System.out.println("Date: " + session.getDate());
     System.out.println("Memo: " + session.getMemo());
     if (session.pkiVerificationData != null) {
       System.out.println("Pki-Verified Name: " + session.pkiVerificationData.name);
       if (session.pkiVerificationData.orgName != null)
         System.out.println("Pki-Verified Org: " + session.pkiVerificationData.orgName);
       System.out.println(
           "PKI data verified by: " + session.pkiVerificationData.rootAuthorityName);
     }
     final Wallet.SendRequest req = session.getSendRequest();
     if (password != null) {
       if (!wallet.checkPassword(password)) {
         System.err.println("Password is incorrect.");
         return;
       }
       req.aesKey = wallet.getKeyCrypter().deriveKey(password);
     }
     wallet.completeTx(req); // may throw InsufficientMoneyException.
     if (options.has("offline")) {
       wallet.commitTx(req.tx);
       return;
     }
     setup();
     // No refund address specified, no user-specified memo field.
     ListenableFuture<PaymentSession.Ack> future =
         session.sendPayment(ImmutableList.of(req.tx), null, null);
     if (future == null) {
       // No payment_url for submission so, broadcast and wait.
       peers.startAndWait();
       peers.broadcastTransaction(req.tx).get();
     } else {
       PaymentSession.Ack ack = future.get();
       wallet.commitTx(req.tx);
       System.out.println("Memo from server: " + ack.getMemo());
     }
   } catch (PaymentRequestException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (VerificationException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (ExecutionException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (IOException e) {
     System.err.println("Invalid payment " + e.getMessage());
     System.exit(1);
   } catch (InterruptedException e1) {
     // Ignore.
   } catch (InsufficientMoneyException e) {
     System.err.println(
         "Insufficient funds: have " + Utils.bitcoinValueToFriendlyString(wallet.getBalance()));
   } catch (BlockStoreException e) {
     throw new RuntimeException(e);
   }
 }
Ejemplo n.º 12
0
 private File getPropertiesFile() {
   if (options.has(propertiesFileSpec)) {
     // a file was explicitly configured
     return new File(options.valueOf(propertiesFileSpec));
   } else {
     return null;
   }
 }
Ejemplo n.º 13
0
 private OptionSet parseOptions(OptionParser p, String[] args) throws IOException {
   OptionSet options = null;
   try {
     options = p.parse(args);
     if (options.has("?")
         || !options.has(maxwiOptName)
         || options.nonOptionArguments().size() < 2) {
       System.err.println("Usage:\nSimilarity <input_paths> <output_path> [options]");
       System.err.println("Please specify " + maxwiOptName + " option\n");
       p.printHelpOn(System.err);
       System.exit(0);
     }
   } catch (OptionException e) {
     System.err.println(e.getMessage());
     System.exit(1);
   }
   return options;
 }
Ejemplo n.º 14
0
 private static Properties asProperties(OptionSet options, String prefix) {
   Properties properties = new Properties();
   for (Entry<OptionSpec<?>, List<?>> entry : options.asMap().entrySet()) {
     OptionSpec<?> spec = entry.getKey();
     properties.setProperty(
         asPropertyKey(prefix, spec), asPropertyValue(entry.getValue(), options.has(spec)));
   }
   return properties;
 }
Ejemplo n.º 15
0
  @Test
  public void testInitOptionsWithHelp_optionalArgument() {
    parser.accepts("argName", "Funky description");

    OptionSet options = initOptionsWithHelp(parser, new String[] {"--argName"});
    assertNotNull(options);
    assertEquals(1, options.specs().size());
    assertTrue(options.has("argName"));
  }
Ejemplo n.º 16
0
  @Test
  public void senderAndReceiverIsOptional() throws Exception {
    OptionParser optionParser = Main.getOptionParser();

    OptionSet optionSet =
        optionParser.parse("-f", "/tmp/dummy", "-u", "https://ap.unit4.com", "-m", "as2");
    assertFalse(optionSet.has("-r"));
    assertFalse(optionSet.has("-s"));
  }
Ejemplo n.º 17
0
  public final void parseAndExecute(final String[] cmds) throws IOException {
    opts = parser.parse(cmds);
    if (opts.has(HELP)) {
      parser.printHelpOn(System.out);
      return;
    }

    Indexing.STORE = opts.has(STORE);
    Indexing.COMMIT = (Integer) opts.valueOf(COMMIT);

    // FORMAT
    if (opts.has(FORMAT)) {
      format = (Format) opts.valueOf(FORMAT);
    } else printError(FORMAT);

    // DUMPS_DIR
    if (opts.has(DUMPS_DIR)) {
      dumpsDir = (File) opts.valueOf(DUMPS_DIR);
    } else printError(DUMPS_DIR);

    // INDEX_DIR
    if (opts.has(INDEX_DIR)) {
      indexDir = (File) opts.valueOf(INDEX_DIR);
    } else printError(INDEX_DIR);

    logger.info(
        "Creating index at {} from the files at {}",
        indexDir.getAbsolutePath(),
        dumpsDir.getAbsolutePath());
    final Indexing indexing;
    switch (format) {
      case SINDICE_DE:
        indexing = new SindiceDEIndexing(dumpsDir, FSDirectory.open(indexDir));
        break;
      case SINDICE_ED:
        indexing = new SindiceEDIndexing(dumpsDir, FSDirectory.open(indexDir));
        break;
      default:
        throw new IllegalArgumentException("No such dataset format: " + format);
    }
    indexing.indexIt();
    indexing.close();
    logger.info("Finished indexing");
  }
Ejemplo n.º 18
0
  public static void main(String[] args) throws IOException, TException {
    OptionParser parser = new OptionParser();
    parser.accepts("c", "configuration file").withRequiredArg().ofType(String.class);
    parser.accepts("help", "print help statement");
    OptionSet options = parser.parse(args);

    if (options.has("help")) {
      parser.printHelpOn(System.out);
      System.exit(-1);
    }

    // Logger configuration: log to the console
    BasicConfigurator.configure();
    LOG.setLevel(Level.DEBUG);
    LOG.debug("debug logging on");

    Configuration conf = new PropertiesConfiguration();

    if (options.has("c")) {
      String configFile = (String) options.valueOf("c");
      try {
        conf = new PropertiesConfiguration(configFile);
      } catch (ConfigurationException e) {
      }
    }
    // Start backend server
    BackendService.Processor<BackendService.Iface> processor =
        new BackendService.Processor<BackendService.Iface>(new ProtoBackend());

    int listenPort = conf.getInt("listen_port", DEFAULT_LISTEN_PORT);
    NM_PORT = conf.getInt("node_monitor_port", NodeMonitorThrift.DEFAULT_NM_THRIFT_PORT);
    TServers.launchThreadedThriftServer(listenPort, THRIFT_WORKER_THREADS, processor);

    // Register server
    client = TClients.createBlockingNmClient(NM_HOST, NM_PORT);

    try {
      client.registerBackend(APP_ID, "localhost:" + listenPort);
      LOG.debug("Client successfullly registered");
    } catch (TTransportException e) {
      LOG.debug("Error while registering backend: " + e.getMessage());
    }
  }
Ejemplo n.º 19
0
 private static void checkRequiredArgs(
     OptionParser parser, OptionSet options, OptionSpec[] required) throws IOException {
   for (OptionSpec arg : required) {
     if (!options.has(arg)) {
       System.err.println("Missing required argument \"" + arg + "\"");
       parser.printHelpOn(System.err);
       System.exit(1);
     }
   }
 }
Ejemplo n.º 20
0
  public static void main(String[] args) throws Exception {
    SaraTouchClient client = new SaraTouchClient();

    OptionParser parser = new OptionParser("ch:p:t");
    OptionSet options = null;

    try {
      options = parser.parse(args);
    } catch (Exception e) {
      System.out.println("Could not parse command-line options:\n" + e);
      System.out.println();
      System.out.println("-h <host>   Server host");
      System.out.println("-p <port>   Server port");
      System.out.println("-t          Send TUIO events instead of mouse events");
      System.out.println("-c          Connect after starting up");
      System.out.println();
      System.exit(-1);
    }

    if (options.has("h")) {
      Object o = options.valueOf("h");
      if (o != null) {
        String s = (String) o;
        client.setHost(s);
      }
    }

    if (options.has("p")) {
      Object o = options.valueOf("p");
      if (o != null) {
        int i = Integer.parseInt((String) o);
        client.setPort(i);
      }
    }

    if (options.has("t")) client.setModeToTUIO();

    if (options.has("c")) client.connect();

    client.setSize(600, 500);
    client.setVisible(true);
  }
Ejemplo n.º 21
0
 static void checkRequiredArgs(
     OptionParser parser, OptionSet options, OptionSpec<?>... optionSepcs) throws IOException {
   for (OptionSpec<?> arg : optionSepcs) {
     if (!options.has(arg)) {
       System.err.println("Missing required argument " + arg);
       // parser.formatHelpWith(new MyFormatter());
       parser.printHelpOn(System.err);
       System.exit(1);
     }
   }
 }
Ejemplo n.º 22
0
  public static void parseArgs(String args[]) throws java.io.IOException {

    parser.acceptsAll(asList("h", "?"), "show help then exit");
    OptionSpec<String> CMD = parser.accepts("c", "command").withRequiredArg().ofType(String.class);
    OptionSpec<String> LOGIN =
        parser.accepts("u", "LoginId").withRequiredArg().ofType(String.class);
    OptionSpec<String> PASSWORD =
        parser.accepts("p", "password").withRequiredArg().ofType(String.class);
    OptionSpec<String> ISSUER =
        parser.accepts("i", "IssuerDN").withRequiredArg().ofType(String.class);
    OptionSpec<String> SUBJECT =
        parser.accepts("s", "SubjectDN").withRequiredArg().ofType(String.class);
    OptionSpec<String> CONTEXT =
        parser
            .accepts("C", "context:UNITTEST,DEVELOPMENT,SDK,PRODUCTION")
            .withRequiredArg()
            .ofType(String.class);

    OptionSet options = parser.parse(args);

    // check for help
    if (options.has("?")) {
      parser.printHelpOn(System.out);
      System.exit(0);
    }
    if (options.has(CMD)) {
      cmd = options.valueOf(CMD);
    } else {
      System.out.println("a -c cmd argument is required");
      parser.printHelpOn(System.out);
      System.exit(0);
    }
    if (options.has(LOGIN)) {
      loginName = options.valueOf(LOGIN);
    }
    if (options.has(PASSWORD)) {
      password = options.valueOf(PASSWORD);
    }
    if (options.has(ISSUER)) {
      issuer = options.valueOf(ISSUER);
    }
    if (options.has(SUBJECT)) {
      subject = options.valueOf(SUBJECT);
    }
    if (options.has(CONTEXT)) {
      context = options.valueOf(CONTEXT);
      if (!context.equals("UNITTEST")
          && !context.equals("SDK")
          && !context.equals("DEVELOPMENT")
          && !context.equals("PRODUCTION")) {
        System.out.println("unrecognized CONTEXT value: " + context);
        System.exit(-1);
      }
    }
  }
Ejemplo n.º 23
0
  public void run() {
    Reflections.log = null;

    printVersion();

    OptionParser parser = buildOptionParser();

    OptionSet options = parser.parse(arguments);
    if (options.has(ARGUMENT_EXPERIMENT)) {
      runExperiment(options.valueOf(ARGUMENT_EXPERIMENT).toString());
      System.exit(0);
    }
    if (options.has(ARGUMENT_EXPERIMENT_LIST)) {
      printExperimentList();
      System.exit(0);
    }
    if (options.has(ARGUMENT_HELP)) {
      printHelp(parser);
      System.exit(0);
    }
    printHelp(parser);
  }
Ejemplo n.º 24
0
  private static OptionSet parseOptions(String[] argv) throws IOException {
    OptionSet args = null;
    OptionParser parser = new OptionParser();
    parser.acceptsAll(Arrays.asList("l", CMD_LIST), "list readers");
    parser.acceptsAll(Arrays.asList("p", OPT_PROVIDER), "specify provider").withRequiredArg();
    parser.acceptsAll(Arrays.asList("v", OPT_VERBOSE), "be verbose");
    parser.acceptsAll(Arrays.asList("e", OPT_ERROR), "fail if not 0x9000");
    parser.acceptsAll(Arrays.asList("h", OPT_HELP), "show help");
    parser.acceptsAll(Arrays.asList("r", OPT_READER), "use reader").withRequiredArg();
    parser.acceptsAll(Arrays.asList("a", CMD_APDU), "send APDU").withRequiredArg();
    parser.acceptsAll(Arrays.asList("w", OPT_WEB), "open ATR in web");
    parser.acceptsAll(Arrays.asList("V", OPT_VERSION), "show version information");
    parser.accepts(OPT_DUMP, "save dump to file").withRequiredArg().ofType(File.class);
    parser.accepts(OPT_REPLAY, "replay command from dump").withRequiredArg().ofType(File.class);

    parser.accepts(OPT_SUN, "load SunPCSC");
    parser.accepts(OPT_JNA, "load jnasmartcardio");
    parser.accepts(OPT_CONNECT, "connect to host:port or URL").withRequiredArg();
    parser.accepts(OPT_PINNED, "require certificate").withRequiredArg().ofType(File.class);

    parser.accepts(OPT_PROVIDERS, "list providers");
    parser.accepts(OPT_ALL, "process all readers");
    parser.accepts(OPT_WAIT, "wait for card insertion");
    parser.accepts(OPT_T0, "use T=0");
    parser.accepts(OPT_T1, "use T=1");
    parser.accepts(OPT_TEST_SERVER, "run a test server on port 10000").withRequiredArg();
    parser.accepts(OPT_NO_GET_RESPONSE, "don't use GET RESPONSE with SunPCSC");
    parser.accepts(OPT_LIB, "use specific PC/SC lib with SunPCSC").withRequiredArg();
    parser.accepts(OPT_PROVIDER_TYPE, "provider type if not PC/SC").withRequiredArg();

    // Parse arguments
    try {
      args = parser.parse(argv);
      // Try to fetch all values so that format is checked before usage
      for (String s : parser.recognizedOptions().keySet()) {
        args.valuesOf(s);
      }
    } catch (OptionException e) {
      if (e.getCause() != null) {
        System.err.println(e.getMessage() + ": " + e.getCause().getMessage());
      } else {
        System.err.println(e.getMessage());
      }
      System.err.println();
      help_and_exit(parser, System.err);
    }
    if (args.has(OPT_HELP)) {
      help_and_exit(parser, System.out);
    }
    return args;
  }
Ejemplo n.º 25
0
 private static void createWallet(OptionSet options, NetworkParameters params, File walletFile)
     throws IOException {
   if (walletFile.exists() && !options.has("force")) {
     System.err.println(
         "Wallet creation requested but " + walletFile + " already exists, use --force");
     return;
   }
   wallet = new Wallet(params);
   if (password != null) {
     wallet.encrypt(password);
     wallet.addNewEncryptedKey(password);
   }
   wallet.saveToFile(walletFile);
 }
Ejemplo n.º 26
0
  void run() {
    try {
      cloudInfo.props.init(getPropertiesFile());

      cloudInfo.locationId = options.valueOf(locationSpec);
      cloudInfo.verbose = options.has(verboseSpec);

      if (options.has(showLocationsSpec)) {
        cloudInfo.init();
        cloudInfo.showLocations();
      } else if (options.has(showHardwareSpec)) {
        cloudInfo.init();
        cloudInfo.showHardware();
      } else if (options.has(showImagesSpec)) {
        cloudInfo.init();
        cloudInfo.showImages();
      } else {
        CliUtils.printHelpAndExit(parser);
      }
    } finally {
      cloudInfo.shutdown();
    }
  }
Ejemplo n.º 27
0
  public static void main(String[] args) {
    OptionParser p = new OptionParser("fc:q::");
    p.accepts("ftp");
    p.accepts("user").requiredIf("ftp").withRequiredArg();
    p.accepts("pass").requiredIf("ftp").withRequiredArg();

    OptionSet opt = p.parse(args);
    if (opt.has("f")) {
      System.out.println("-f exist");
      System.out.println("-f with : " + opt.valueOf("f"));
    }
    if (opt.has("c")) {
      System.out.println("-c exist with:" + opt.valueOf("c"));
    }

    if (opt.has("ftp")) {
      // we know username and password
      // existe if -ftp is set
      String user = (String) opt.valueOf("user");
      String pwd = (String) opt.valueOf("pass");
      System.out.println("user:"******" pass:" + pwd);
    }
  }
 /**
  * Process the options found in the commandline arguments and checks that all required options are
  * present.
  *
  * @param opts
  * @param cfg
  * @throws Exception
  */
 private static void processOptions(OptionSet opts, ConfigurationOptions cfg) throws Exception {
   if (opts.has("N")) {
     cfg.numNodes = Integer.parseInt(opts.valueOf("N").toString());
   } else throw new Exception("Argument --num-nodes is required");
   if (opts.has("C")) {
     cfg.numVehicles = Integer.parseInt(opts.valueOf("C").toString());
   } else throw new Exception("Argument --num-vehicles is required");
   if (opts.has("D")) {
     cfg.degreeProb = Integer.parseInt(opts.valueOf("D").toString()) / (double) cfg.numNodes;
   } else throw new Exception("Argument --node-degree is required");
   if (opts.has("node-capacity")) {
     cfg.capacity = Integer.parseInt(opts.valueOf("node-capacity").toString());
   } // this argument is optional
   if (opts.has("o")) {
     cfg.outputFile = new File(opts.valueOf("o").toString());
   } else throw new Exception("Argument --output-file is required");
   if (opts.has("d")) {
     String s = opts.valueOf("d").toString();
     String[] ss = s.split(":");
     if (ss.length != 2) throw new Exception("Argument to node-delay must have the form min:max");
     cfg.nodeDelay[0] = Integer.parseInt(ss[0]);
     cfg.nodeDelay[1] = Integer.parseInt(ss[1]);
   } else throw new Exception("Argument --node-delay is required");
   if (opts.has("S")) {
     String[] ss = opts.valueOf("S").toString().split(",");
     for (String s : ss) {
       cfg.strategies.add(s);
     }
   } else throw new Exception("Argument --vehicle-strategies is required");
   if (opts.has("one-way-prob")) {
     cfg.oneWay = Double.parseDouble(opts.valueOf("one-way-prob").toString());
   }
   cfg.bottleneck = opts.has("congested");
   if (opts.has("graph")) {
     cfg.graphFile = new File(opts.valueOf("graph").toString());
   }
 }
Ejemplo n.º 29
0
  @Override
  public int call(BurlapShell shell, String argString, Scanner is, PrintStream os) {

    OptionSet oset = this.parser.parse(argString.split(" "));
    List<String> args = (List<String>) oset.nonOptionArguments();
    if (oset.has("h")) {
      os.println(
          "[-v] objectClass objectName\nAdds an OO-MDP object instance of class objectClass and with name "
              + "objectName to the current state of the world."
              + "The Java ObjectInstance implementation used will be MutableObjectInstance.\n\n"
              + "-v print the new world state after completion.");
      return 0;
    }

    World w = ((SGWorldShell) shell).getWorld();

    if (w.gameIsRunning()) {
      os.println("Cannot manually change state while a game is running.");
      return 0;
    }

    if (args.size() != 2) {
      return -1;
    }

    ObjectInstance o = new MutableObjectInstance(domain.getObjectClass(args.get(0)), args.get(1));
    State s = w.getCurrentWorldState().copy();
    s.addObject(o);
    w.setCurrentState(s);

    if (oset.has("v")) {
      os.println(s.getCompleteStateDescriptionWithUnsetAttributesAsNull());
    }

    return 1;
  }
Ejemplo n.º 30
0
  @Test
  public void supportsOptionSynonyms() {
    OptionParser parser = new OptionParser();
    List<String> synonyms = asList("message", "blurb", "greeting");
    parser.acceptsAll(synonyms).withRequiredArg();
    String expectedMessage = "Hello";

    OptionSet options = parser.parse("--message", expectedMessage);

    for (String each : synonyms) {
      assertTrue(each, options.has(each));
      assertTrue(each, options.hasArgument(each));
      assertEquals(each, expectedMessage, options.valueOf(each));
      assertEquals(each, asList(expectedMessage), options.valuesOf(each));
    }
  }