Ejemplo n.º 1
0
  /** @param args */
  public static void main(String[] args) {
    try {
      System.out.println("Program started...");

      System.out.println("Parsing command line arguments...");
      OptionsParser options = new OptionsParser(args);
      System.out.println("Parsing command line arguments ended.");

      System.out.println("Connecting to device...");
      INovacomController controller = Novacom.getController();
      INovacomDevice device = controller.connectDefaultDevice();
      System.out.println("Connected to device successfully.");

      System.out.println("Acquiring filesystem...");
      PalmSynchronizer sync = new PalmSynchronizer();
      String devicePath = options.GetDevicePath();
      String backupPath = options.GetBackupPath();

      sync.AcquireItems(device, devicePath, backupPath);

      System.out.println("Acquiring filesystem finished.");
      System.out.println("Program ended successfully.");
    } catch (Exception e) {
      System.out.println("Program failed.");
      e.printStackTrace();
    }
  }
Ejemplo n.º 2
0
  /**
   * Implementation of Tool::run(). Orchestrates the copy of source file(s) to target location, by:
   * 1. Creating a list of files to be copied to target. 2. Launching a Map-only job to copy the
   * files. (Delegates to execute().)
   *
   * @param argv: List of arguments passed to DistCp, from the ToolRunner.
   * @return On success, it returns 0. Else, -1.
   */
  public int run(String[] argv) {
    try {
      inputOptions = (OptionsParser.parse(argv));

      LOG.info("Input Options: " + inputOptions);
    } catch (Throwable e) {
      LOG.error("Invalid arguments: ", e);
      System.err.println("Invalid arguments: " + e.getMessage());
      OptionsParser.usage();
      return DistCpConstants.INVALID_ARGUMENT;
    }

    try {
      execute();
    } catch (InvalidInputException e) {
      LOG.error("Invalid input: ", e);
      return DistCpConstants.INVALID_ARGUMENT;
    } catch (DuplicateFileException e) {
      LOG.error("Duplicate files in input path: ", e);
      return DistCpConstants.DUPLICATE_INPUT;
    } catch (Exception e) {
      LOG.error("Exception encountered ", e);
      return DistCpConstants.UNKNOWN_ERROR;
    }
    return DistCpConstants.SUCCESS;
  }
Ejemplo n.º 3
0
 // Might want to call this again after some command-line options were changed.
 public static void printOptions() {
   boolean saveMakeThunk = makeThunk;
   makeThunk = false;
   parser.doGetOptionPairs().printEasy(getFile("options.map"));
   parser.doGetOptionStrings().printEasy(getFile("options.help"));
   makeThunk = saveMakeThunk;
 }
Ejemplo n.º 4
0
 @Override
 public void initOptionsParser(OptionsParser optsParser) {
   optsParser
       .setOption("splitSep=<regex>", "Define custom split seperator.")
       .setOption("joinSep=<regex>", "Define custom join seperator when printing.")
       .setOption("inputFile=<file>", "Specify input file.")
       .setOption("reverseCut", "Keep the cut column and remove others.")
       .setSummary(
           "Split each input line and cut out the zero based column specified.\n"
               + "If no inputFile is given then STDIN is used.\n"
               + "\n"
               + "You may use negative indexing on cutting column. When using negative\n"
               + "indexes, make sure you use \"--\" after thec command so it will not\n"
               + "parse as option flag.\n"
               + "")
       .setUsage("ztool Cut [Options] [cutColumnIdx ...]\n")
       .setExamples(
           "  ztool Cut 2 --inputFile=data.txt\n"
               + "  ztool Printf \"a b c\\nd e f\" | ztool Cut 2\n"
               + "  ztool Printf \"a b c\\nd e f\" | ztool Cut -- -1\n"
               + "  ztool Printf \"a b c\\nd e f\" | ztool Cut -r -- -1\n"
               + "  ztool Printf \"a|b|c\\nd|e|f\" | ztool Cut --splitSep=\"\\|\"\n"
               + "  ztool Printf \"a|b|c\\nd|e|f\" | ztool Cut --splitSep=\"\\|\" 1\n"
               + "");
 }
  /**
   * Constructs a build from a list of command args. Sets the same JavacRunner for both compilation
   * and annotation processing.
   *
   * @param optionsParser the parsed command line args.
   * @param extraPlugins extraneous plugins to use in addition to the strict dependency module.
   * @param depsBuilder a preconstructed dependency module builder.
   * @throws InvalidCommandLineException on any command line error
   */
  public JavaLibraryBuildRequest(
      OptionsParser optionsParser,
      List<BlazeJavaCompilerPlugin> extraPlugins,
      DependencyModule.Builder depsBuilder)
      throws InvalidCommandLineException, IOException {
    depsBuilder.addDirectMappings(optionsParser.getDirectMappings());
    depsBuilder.addIndirectMappings(optionsParser.getIndirectMappings());
    if (optionsParser.getStrictJavaDeps() != null) {
      depsBuilder.setStrictJavaDeps(optionsParser.getStrictJavaDeps());
    }
    if (optionsParser.getOutputDepsProtoFile() != null) {
      depsBuilder.setOutputDepsProtoFile(optionsParser.getOutputDepsProtoFile());
    }
    depsBuilder.addDepsArtifacts(optionsParser.getDepsArtifacts());
    if (optionsParser.reduceClasspath()) {
      depsBuilder.setReduceClasspath();
    }
    if (optionsParser.getRuleKind() != null) {
      depsBuilder.setRuleKind(optionsParser.getRuleKind());
    }
    if (optionsParser.getTargetLabel() != null) {
      depsBuilder.setTargetLabel(optionsParser.getTargetLabel());
    }
    this.dependencyModule = depsBuilder.build();

    AnnotationProcessingModule.Builder processingBuilder = AnnotationProcessingModule.builder();
    if (optionsParser.getSourceGenDir() != null) {
      processingBuilder.setSourceGenDir(Paths.get(optionsParser.getSourceGenDir()));
    }
    if (optionsParser.getManifestProtoPath() != null) {
      processingBuilder.setManifestProtoPath(Paths.get(optionsParser.getManifestProtoPath()));
    }
    processingBuilder.addAllSourceRoots(optionsParser.getSourceRoots());
    this.processingModule = processingBuilder.build();

    ImmutableList.Builder<BlazeJavaCompilerPlugin> pluginsBuilder =
        ImmutableList.<BlazeJavaCompilerPlugin>builder().add(dependencyModule.getPlugin());
    processingModule.registerPlugin(pluginsBuilder);
    pluginsBuilder.addAll(extraPlugins);
    this.plugins = pluginsBuilder.build();

    this.compressJar = optionsParser.compressJar();
    this.sourceFiles = optionsParser.getSourceFiles();
    this.sourceJars = ImmutableList.copyOf(optionsParser.getSourceJars());
    this.messageFiles = ImmutableList.copyOf(optionsParser.getMessageFiles());
    this.resourceFiles = ImmutableList.copyOf(optionsParser.getResourceFiles());
    this.resourceJars = ImmutableList.copyOf(optionsParser.getResourceJars());
    this.rootResourceFiles = ImmutableList.copyOf(optionsParser.getRootResourceFiles());
    this.classPath = optionsParser.getClassPath();
    this.extdir = optionsParser.getExtdir();
    this.processorPath = optionsParser.getProcessorPath();
    this.processorNames = optionsParser.getProcessorNames();
    // Since the default behavior of this tool with no arguments is "rm -fr <classDir>", let's not
    // default to ".", shall we?
    if (optionsParser.getClassDir() != null) {
      this.classDir = optionsParser.getClassDir();
    } else {
      this.classDir = "classes";
    }
    if (optionsParser.getTempDir() != null) {
      this.tempDir = optionsParser.getTempDir();
    } else {
      this.tempDir = "_tmp";
    }
    this.outputJar = optionsParser.getOutputJar();
    ImmutableList.Builder<AbstractPostProcessor> postProcessors = ImmutableList.builder();
    for (Entry<String, List<String>> entry : optionsParser.getPostProcessors().entrySet()) {
      postProcessors.add(AbstractPostProcessor.create(entry.getKey(), entry.getValue()));
    }
    this.postProcessors = postProcessors.build();
    this.javacOpts = ImmutableList.copyOf(optionsParser.getJavacOpts());
    this.sourceGenDir = optionsParser.getSourceGenDir();
    this.generatedSourcesOutputJar = optionsParser.getGeneratedSourcesOutputJar();
    this.generatedClassOutputJar = optionsParser.getManifestProtoPath();
  }
Ejemplo n.º 6
0
  public static void init(String[] args, Object... objects) {
    // Parse options
    parser = new OptionsParser();
    parser.doRegister("log", LogInfo.class);
    parser.doRegister("exec", Execution.class);
    parser.doRegisterAll(objects);
    // These options are specific to the execution, so we don't want to overwrite them
    // with a previous execution's.
    parser.setDefaultDirFileName("options.map");
    parser.setIgnoreOptsFromFileName(
        "options.map",
        ListUtils.newList(
            "log.file",
            "exec.execDir",
            "exec.execPoolDir",
            "exec.actualPoolDir",
            "exec.makeThunk"));
    if (!parser.doParse(args)) System.exit(1);

    // Load classes
    if (jarFiles.size() > 0) {
      List<String> names = new ArrayList();
      for (String jarFile : jarFiles) names.add(new File(jarFile).getName());
      stderr.println("Loading JAR files: " + StrUtils.join(names));
      for (String jarFile : jarFiles) // Load classes
      ClassInitializer.initializeJar(jarFile);
    }
    // Set character encoding
    if (charEncoding != null) CharEncUtils.setCharEncoding(charEncoding);

    if (printOptionsAndExit) { // Just print options and exit
      parser.doGetOptionPairs().print(stdout);
      System.exit(0);
    }

    // Create a new directory
    if (create) {
      createVirtualExecDir();
      stderr.println(virtualExecDir);
      if (!makeThunk) LogInfo.file = getFile("log");

      // Copy the Jar files for reference
      if (!makeThunk) {
        for (String jarFile : jarFiles)
          Utils.systemHard(String.format("cp %s %s", jarFile, virtualExecDir));
      }
    } else {
      LogInfo.file = "";
    }

    if (!makeThunk) {
      LogInfo.init();
      if (startMainTrack) track("main()", true);
    }

    // Output options
    if (!makeThunk && virtualExecDir != null) logs("Execution directory: " + virtualExecDir);
    if (!makeThunk) getInfo().printEasy(getFile("info.map"));
    printOptions();
    if (create && addToView.size() > 0)
      IOUtils.printLinesHard(Execution.getFile("addToView"), addToView);

    // Start monitoring
    if (!makeThunk && monitor) {
      monitorThread = new MonitorThread();
      monitorThread.start();
    }

    if (!makeThunk) Record.init(Execution.getFile("record"));
  }