Beispiel #1
0
  @Override
  public int run(String[] args) throws Exception {
    try {
      jc.parse(args);
    } catch (ParameterException pe) {
      System.err.println(pe.getMessage());
      return 1;
    }

    if ("help".equals(jc.getParsedCommand())) {
      return help.usage(jc, COMMANDS);
    }

    Command cmd = COMMANDS.get(jc.getParsedCommand());
    if (cmd == null) {
      return help.usage(jc, COMMANDS);
    }
    try {
      return cmd.execute(getConf());
    } catch (CommandException ce) {
      System.err.println("Command Error: " + ce.getMessage());
      return 1;
    } catch (IllegalArgumentException e) {
      System.err.println("Argument Error: " + e.getMessage());
      return 1;
    } catch (IllegalStateException e) {
      System.err.println("State Error: " + e.getMessage());
      return 1;
    }
  }
Beispiel #2
0
 private boolean parse(String[] args) {
   try {
     new JCommander(this, args);
     return true;
   } catch (ParameterException e) {
     System.err.println("Arguments parse error: " + e.getMessage());
     printUsage();
     return false;
   }
 }
 private static UserArguments parseUserArguments(String[] args) {
   UserArguments userArguments = new UserArguments();
   try {
     new JCommander(userArguments, args);
   } catch (ParameterException e) {
     e.printStackTrace(System.err);
     new JCommander(userArguments, new String[] {"-help"}).usage();
   }
   return userArguments;
 }
Beispiel #4
0
  public static void main(String[] args) {
    /* Parse and validate command line parameters */
    CommandLineParameters params = new CommandLineParameters();
    try {
      JCommander jc = new JCommander(params, args);
      if (params.help) {
        jc.setProgramName("java -Xmx[several]G -jar otp.jar");
        jc.usage();
        System.exit(0);
      }
      params.infer();
    } catch (ParameterException pex) {
      LOG.error("Parameter error: {}", pex.getMessage());
      System.exit(1);
    }

    OTPConfigurator configurator = new OTPConfigurator(params);

    // start graph builder, if asked for
    GraphBuilderTask graphBuilder = configurator.builderFromParameters();
    if (graphBuilder != null) {
      graphBuilder.run();
      // Inform configurator which graph is to be used for in-memory handoff.
      if (params.inMemory) configurator.makeGraphService(graphBuilder.getGraph());
    }

    // start visualizer, if asked for
    GraphVisualizer graphVisualizer = configurator.visualizerFromParameters();
    if (graphVisualizer != null) {
      graphVisualizer.run();
    }

    // start web server, if asked for
    GrizzlyServer grizzlyServer = configurator.serverFromParameters();
    if (grizzlyServer != null) {
      while (true) { // Loop to restart server on uncaught fatal exceptions.
        try {
          grizzlyServer.run();
          return;
        } catch (Throwable throwable) {
          throwable.printStackTrace();
          LOG.error(
              "An uncaught {} occurred inside OTP. Restarting server.",
              throwable.getClass().getSimpleName());
        }
      }
    }

    if (graphBuilder == null && graphVisualizer == null && grizzlyServer == null) {
      LOG.info("Nothing to do. Use --help to see available tasks.");
      ;
    }
  }
  public static void main(String[] args) {
    class Arguments {
      @Parameter(
          names = {"-m", "--matrix"},
          description = "Matrix definition path.",
          required = true)
      private String matrix;

      @Parameter(
          names = {"-r", "--repo"},
          description = "Repository path.",
          required = true)
      private String repository;

      @Parameter(
          names = {"-f", "--factor"},
          description = "Scaling factor.")
      private int factor = 10;

      @Parameter(
          names = {"-n", "--name"},
          description = "User name.")
      private String name = "";

      @Parameter(
          names = {"-e", "--email"},
          description = "Email address.")
      private String email = "";
    }

    try {
      Arguments arguments = new Arguments();
      new JCommander(arguments, args);

      try (Repository repository =
          new Repository(Paths.get(arguments.repository), arguments.name, arguments.email)) {
        repository.illustrate(new Matrix(Paths.get(arguments.matrix)), arguments.factor);
      }
    } catch (ParameterException error) {
      System.err.println(error.getMessage());
    } catch (IOException | Matrix.FileFormatException | Repository.GitException error) {
      LOGGER.severe(error.toString());
    }
  }
  /**
   * Parses command line arguments and populates this command line instance.
   *
   * <p>If the command line arguments include the "help" argument, or if the arguments have
   * incorrect values or order, then usage information is printed to {@link System#out} and the
   * program terminates.
   *
   * @param args the command line arguments
   * @return an instance of the parsed arguments object
   */
  public Arguments parse(String[] args) {

    JCommander jCommander = new JCommander(this);
    jCommander.setProgramName("jsonschema2pojo");

    try {
      jCommander.parse(args);

      if (this.showHelp) {
        jCommander.usage();
        exit(EXIT_OKAY);
      }
    } catch (ParameterException e) {
      System.err.println(e.getMessage());
      jCommander.usage();
      exit(EXIT_ERROR);
    }

    return this;
  }
  public static void main(String[] args) {
    final Options options = new Options();
    JCommander jCommander = new JCommander(options);
    jCommander.setProgramName("java -jar ColorBleeding.jar");
    try {
      String inPath = "/tmp/images";
      String[] argv = {
          /* "-overwrite", */
        "-dir",
        inPath,
        "-debug",
        "-maxiterations",
        "2",
        "-outdir",
        "/tmp/result",
        "-numthreads",
        "8"
      };

      if (System.getProperty("overrideArgs", "false").equals("true")) {
        args = argv;
      }

      jCommander.parse(args);

      execute(options);

    } catch (ParameterException e) {
      logger.error(e.getMessage());
      if (jCommander != null) {
        jCommander.usage();
      }
    } catch (IOException e) {
      logger.error("Error while processing images", e);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Beispiel #8
0
  public static void main(String... args) {
    CommandLineArgs parsedArgs = new CommandLineArgs();
    JCommander jc = new JCommander(parsedArgs);

    try {
      jc.parse(args);
    } catch (ParameterException e) {
      StringBuilder out = new StringBuilder(e.getLocalizedMessage()).append("\n\n");
      jc.usage(out);
      System.err.println(out.toString());
      System.exit(1);
      return;
    }
    if (parsedArgs.help) {
      jc.usage();
      return;
    }

    SpoonRunner spoonRunner =
        new SpoonRunner.Builder() //
            .setTitle(parsedArgs.title)
            .setApplicationApk(parsedArgs.apk)
            .setInstrumentationApk(parsedArgs.testApk)
            .setOutputDirectory(parsedArgs.output)
            .setDebug(parsedArgs.debug)
            .setAndroidSdk(parsedArgs.sdk)
            .setNoAnimations(parsedArgs.noAnimations)
            .setTestSize(parsedArgs.size)
            .setAdbTimeout(parsedArgs.adbTimeoutSeconds * 1000)
            .setClassName(parsedArgs.className)
            .setMethodName(parsedArgs.methodName)
            .useAllAttachedDevices()
            .build();

    if (!spoonRunner.run() && parsedArgs.failOnFailure) {
      System.exit(1);
    }
  }
  @Override
  public int run(String[] args) throws Exception {
    // Validate params etc
    JCommander jComm = new JCommander(this);
    jComm.setProgramName("Splout Page Counts example");
    try {
      jComm.parse(args);
    } catch (ParameterException e) {
      System.err.println(e.getMessage());
      jComm.usage();
      System.exit(-1);
    }

    boolean generate = !noGenerate; // just for clarifying

    if (generateTupleFiles && deploy) {
      System.err.println("Can't run a 'dry' TupleFile generation and deploy it.");
      jComm.usage();
      System.exit(-1);
    }

    Path outPath = new Path(outputPath);
    FileSystem outFs = outPath.getFileSystem(getConf());

    if (!FileSystem.getLocal(conf).equals(FileSystem.get(conf))) {
      File nativeLibs = new File("native");
      if (nativeLibs.exists()) {
        SploutHadoopConfiguration.addSQLite4JavaNativeLibsToDC(conf);
      }
    }

    if (generate) {
      Path inputPath = new Path(this.inputPath);
      FileSystem inputFileSystem = inputPath.getFileSystem(conf);

      FileStatus[] fileStatuses = inputFileSystem.listStatus(inputPath);

      // define the schema that the resultant table will have: date, hour, pagename, pageviews
      final Schema tableSchema =
          new Schema(
              "pagecounts",
              Fields.parse("date:string, hour:string, pagename:string, pageviews:int"));
      // define the schema of the input files: projectcode, pagename, pageviews, bytes
      Schema fileSchema =
          new Schema(
              "pagecountsfile",
              Fields.parse("projectcode:string, pagename:string, pageviews:int, bytes:long"));

      // instantiate a TableBuilder
      TableBuilder tableBuilder = new TableBuilder(tableSchema);

      // for every input file...
      for (FileStatus fileStatus : fileStatuses) {
        String fileName = fileStatus.getPath().getName().toString();
        // strip the date and the hour from the file name
        String fileDate = fileName.split("-")[1];
        String fileHour = fileName.split("-")[2].substring(0, 2);
        // instantiate a custom RecordProcessor to process the records of this file
        PageCountsRecordProcessor recordProcessor =
            new PageCountsRecordProcessor(tableSchema, fileDate, fileHour);
        // use the tableBuilder method for adding each of the files to the mix
        tableBuilder.addCSVTextFile(
            fileStatus.getPath(),
            ' ',
            TupleTextInputFormat.NO_QUOTE_CHARACTER,
            TupleTextInputFormat.NO_ESCAPE_CHARACTER,
            false,
            false,
            TupleTextInputFormat.NO_NULL_STRING,
            fileSchema,
            recordProcessor);
      }

      // partition the dataset by pagename - which should give a fair even distribution.
      tableBuilder.partitionBy("pagename");
      // create a compound index on pagename, date so that typical queries for the dataset will be
      // fast
      tableBuilder.createIndex("pagename", "date");

      long nonExactPageSize = memoryForIndexing / 32000; // number of pages
      int pageSize = (int) Math.pow(2, (int) Math.round(Math.log(nonExactPageSize) / Math.log(2)));
      Log.info(
          "Pagesize = "
              + pageSize
              + " as memory for indexing was ["
              + memoryForIndexing
              + "] and there are 32000 pages.");

      tableBuilder.initialSQL("pragma page_size=" + pageSize);
      // insertion order is very important for optimizing query speed because it makes data be
      // co-located in disk
      tableBuilder.insertionSortOrder(OrderBy.parse("pagename:asc, date:asc"));

      // instantiate a TablespaceBuilder
      TablespaceBuilder tablespaceBuilder = new TablespaceBuilder();

      // we will partition this dataset in as many partitions as:
      tablespaceBuilder.setNPartitions(nPartitions);
      tablespaceBuilder.add(tableBuilder.build());
      // we turn a specific SQLite pragma on for making autocomplete queries fast
      tablespaceBuilder.initStatements("pragma case_sensitive_like=true;");

      HadoopUtils.deleteIfExists(outFs, outPath);

      // finally, instantiate a TablespaceGenerator and execute it
      TablespaceGenerator tablespaceViewBuilder;

      if (generateTupleFiles) {
        // we subclass TablespaceGenerator to be able to run the generation without outputting the
        // SQLite stores, for
        // benchmark comparisons.
        // In the future this feature may be useful in general for debugging store creation.
        tablespaceViewBuilder =
            new TablespaceGenerator(tablespaceBuilder.build(), outPath) {

              @Override
              public void generateView(
                  Configuration conf, SamplingType samplingType, SamplingOptions samplingOptions)
                  throws Exception {

                prepareOutput(conf);
                final int nPartitions = tablespace.getnPartitions();
                if (nPartitions > 1) {
                  partitionMap = sample(nPartitions, conf, samplingType, samplingOptions);
                } else {
                  partitionMap = PartitionMap.oneShardOpenedMap();
                }
                writeOutputMetadata(conf);

                TupleMRBuilder builder = createMRBuilder(nPartitions, conf);
                // Set a TupleOutput here instead of SQLiteOutput
                builder.setOutput(
                    new Path(outputPath, OUT_STORE),
                    new TupleOutputFormat(tableSchema),
                    ITuple.class,
                    NullWritable.class);
                Job job = builder.createJob();
                executeViewGeneration(job);
              }
            };
      } else {
        // ... otherwise a standard TablespaceGenerator is used.
        tablespaceViewBuilder = new TablespaceGenerator(tablespaceBuilder.build(), outPath);
      }

      tablespaceViewBuilder.generateView(
          getConf(), SamplingType.RESERVOIR, new TupleSampler.DefaultSamplingOptions());
    }

    if (deploy) {
      // use StoreDeployerTool for deploying the already generated dataset
      StoreDeployerTool deployer = new StoreDeployerTool(qnode, getConf());
      ArrayList<TablespaceDepSpec> deployments = new ArrayList<TablespaceDepSpec>();
      deployments.add(new TablespaceDepSpec("pagecounts", outPath.toString(), repFactor, null));
      deployer.deploy(deployments);
    }
    return 1;
  }
  /**
   * @param args
   * @throws IOException
   * @throws MarshallingException
   */
  public static void main(final String[] args) throws Exception {
    final Arguments arguments = new Arguments();
    final JCommander commander = new JCommander(arguments);
    try {
      commander.parse(args);
    } catch (final ParameterException e) {
      System.err.println(e.getMessage());
      final StringBuilder builder = new StringBuilder();
      commander.usage(builder);
      System.err.println(builder);
      return;
    }

    final KeyStore keystore = KeyStore.getInstance("jks");
    InputStream keystoreStream = null;
    try {
      keystoreStream = new FileInputStream(arguments.getKeystore());
      keystore.load(keystoreStream, arguments.getKeystorePassword().toCharArray());
    } finally {
      if (keystoreStream != null) keystoreStream.close();
    }

    final Map<String, String> keyPasswords = new HashMap<>();

    if (arguments.getEncryptionKey() != null)
      keyPasswords.put(arguments.getEncryptionKey(), arguments.getEncryptionKeyPassword());

    if (arguments.getSigningKey() != null)
      keyPasswords.put(arguments.getSigningKey(), arguments.getSigningKeyPassword());

    if (arguments.getTlsKey() != null)
      keyPasswords.put(arguments.getTlsKey(), arguments.getTlsKeyPassword());

    bootstrap();

    final JKSKeyManager keyManager = new JKSKeyManager(keystore, keyPasswords, null);
    final MetadataGenerator generator = new MetadataGenerator();
    generator.setKeyManager(keyManager);

    generator.setEntityId(arguments.getEntityId());
    generator.setEntityAlias(arguments.getAlias());
    generator.setEntityBaseURL(arguments.getBaseURL());
    generator.setSignMetadata(arguments.isSignMetadata());
    generator.setRequestSigned(arguments.isRequestSigned());
    generator.setWantAssertionSigned(arguments.isWantAssertionSigned());
    generator.setSigningKey(arguments.getSigningKey());
    generator.setEncryptionKey(arguments.getEncryptionKey());

    if (arguments.getTlsKey() != null && arguments.getTlsKey().length() > 0) {
      generator.setTlsKey(arguments.getTlsKey());
    }

    final Collection<String> bindingsSSO = new LinkedList<String>();
    final Collection<String> bindingsHoKSSO = new LinkedList<String>();
    final AllowedSSOBindings defaultBinding = arguments.getSsoDefaultBinding();

    int assertionConsumerIndex = 0;

    for (final AllowedSSOBindings binding : arguments.getSsoBindings()) {

      // Set default binding
      if (binding.equals(defaultBinding)) {
        assertionConsumerIndex = bindingsSSO.size() + bindingsHoKSSO.size();
      }

      // Set included bindings
      if (AllowedSSOBindings.SSO_POST.equals(binding)) {
        bindingsSSO.add(SAMLConstants.SAML2_POST_BINDING_URI);
      } else if (AllowedSSOBindings.SSO_ARTIFACT.equals(binding)) {
        bindingsSSO.add(SAMLConstants.SAML2_ARTIFACT_BINDING_URI);
      } else if (AllowedSSOBindings.SSO_PAOS.equals(binding)) {
        bindingsSSO.add(SAMLConstants.SAML2_PAOS_BINDING_URI);
      } else if (AllowedSSOBindings.HOKSSO_POST.equals(binding)) {
        bindingsHoKSSO.add(SAMLConstants.SAML2_POST_BINDING_URI);
      } else if (AllowedSSOBindings.HOKSSO_ARTIFACT.equals(binding)) {
        bindingsHoKSSO.add(SAMLConstants.SAML2_ARTIFACT_BINDING_URI);
      }
    }

    // Set bindings
    generator.setBindingsSSO(bindingsSSO);
    generator.setBindingsHoKSSO(bindingsHoKSSO);
    generator.setAssertionConsumerIndex(assertionConsumerIndex);

    // Discovery
    if (arguments.isIncludeDiscovery()) {
      generator.setIncludeDiscovery(true);
      if (arguments.getCustomDiscoveryURL() != null
          && arguments.getCustomDiscoveryURL().length() > 0) {
        generator.setCustomDiscoveryURL(arguments.getCustomDiscoveryURL());
      }
    } else {
      generator.setIncludeDiscovery(false);
    }

    generator.setNameID(arguments.getNameID());

    final EntityDescriptor descriptor = generator.generateMetadata();
    final ExtendedMetadata extendedMetadata = generator.generateExtendedMetadata();
    extendedMetadata.setSecurityProfile(arguments.getSecurityProfile());
    extendedMetadata.setSslSecurityProfile(arguments.getSslSecurityProfile());
    extendedMetadata.setRequireLogoutRequestSigned(arguments.isRequireLogoutRequestSigned());
    extendedMetadata.setRequireLogoutResponseSigned(arguments.isRequireLogoutResponseSigned());
    extendedMetadata.setRequireArtifactResolveSigned(arguments.isRequireArtifactResolveSigned());

    Writer metadataWriter = null;
    try {
      metadataWriter = new FileWriter(arguments.getMetadataOutput());
      metadataWriter.write(getMetadataAsString(descriptor));
    } finally {
      if (metadataWriter != null) {
        metadataWriter.flush();
        metadataWriter.close();
      }
    }

    if (arguments.getExtendedMetadataOutput() != null) {
      Writer extendedMetadataWriter = null;
      try {
        extendedMetadataWriter = new FileWriter(arguments.getExtendedMetadataOutput());
        extendedMetadataWriter.write(
            getConfiguration(arguments.getExtendedMetadataOutput().getName(), extendedMetadata));
      } finally {
        if (extendedMetadataWriter != null) {
          extendedMetadataWriter.flush();
          extendedMetadataWriter.close();
        }
      }
    }
  }
Beispiel #11
0
  @Override
  public int run(String[] args) throws Exception {

    if (getConf() != null) {
      DefaultConfiguration.set(getConf());
    }

    try {
      jc.parse(args);
    } catch (MissingCommandException e) {
      console.error(e.getMessage());
      return 1;
    } catch (ParameterException e) {
      console.error(e.getMessage());
      return 1;
    }

    // configure log4j
    if (debug) {
      org.apache.log4j.Logger console = org.apache.log4j.Logger.getLogger(Main.class);
      console.setLevel(Level.DEBUG);
    }

    String parsed = jc.getParsedCommand();
    if (parsed == null) {

      console.error("Unable to parse command.");
      return 1;
    }

    Command command = (Command) jc.getCommands().get(parsed).getObjects().get(0);
    if (command == null) {

      console.error("Unable to find command.");
      return 1;
    }

    try {
      if (command instanceof Configurable) {
        ((Configurable) command).setConf(getConf());
      }
      return command.run();
    } catch (IllegalArgumentException e) {
      if (debug) {
        console.error("Argument error", e);
      } else {
        console.error("Argument error: {}", e.getMessage());
      }
      return 1;
    } catch (IllegalStateException e) {
      if (debug) {
        console.error("State error", e);
      } else {
        console.error("State error: {}", e.getMessage());
      }
      return 1;
    } catch (ValidationException e) {
      if (debug) {
        console.error("Validation error", e);
      } else {
        console.error("Validation error: {}", e.getMessage());
      }
      return 1;
    } catch (DatasetNotFoundException e) {
      if (debug) {
        console.error("Cannot find dataset", e);
      } else {
        // the error message already contains "No such dataset: <name>"
        console.error(e.getMessage());
      }
      return 1;
    } catch (DatasetIOException e) {
      if (debug) {
        console.error("IO error", e);
      } else {
        console.error("IO error: {}", e.getMessage());
      }
      return 1;
    } catch (Exception e) {
      if (debug) {
        console.error("Unknown error", e);
      } else {
        console.error("Unknown error: {}", e.getMessage());
      }
      return 1;
    }
  }