protected void executeScript(
      final String script, final boolean spawn, final String... arguments) {
    ExecTask exec = ant.createTask(ExecTask.class);
    exec.setExecutable(script);

    if (spawn) {
      exec.setSpawn(true);
    } else {
      exec.setFailIfExecutionFails(true);
      exec.setFailonerror(true);
    }

    if (arguments != null) {
      for (String argument : arguments) {
        Commandline.Argument arg = exec.createArg();
        arg.setValue(argument);
      }
    }

    exec.setDir(new File(getConfiguration().getTargetDirectory(), getName()));
    exec.setFailIfExecutionFails(true);

    final Environment.Variable javaHome = new Environment.Variable();
    javaHome.setKey("JAVA_HOME");
    javaHome.setValue(System.getProperty("java.home"));
    exec.addEnv(javaHome);

    if (arguments != null && arguments.length > 0) {
      log.debug("Executing {} with arguments: {}", script, arguments);
    } else {
      log.debug("Executing {}", script);
    }

    exec.execute();
  }
 /**
  * Prepares a command line argument object for use with the appclient exec task that uses the
  * default set of arguments: the default location and name for the retreived app client jar file.
  *
  * @param exec the ExecTask with which the command line should be associated
  * @return the argument, associated with the exec task, and set to invoke the gen'd app client
  */
 protected Commandline.Argument prepareRunCommandlineArg(ExecTask exec) {
   Commandline.Argument arg = exec.createArg();
   String archiveDir = project.getProperty("archivedir");
   String testName = project.getProperty("testName");
   arg.setLine("-client " + archiveDir + "/" + testName + "Client.jar");
   return arg;
 }
  /**
   * Constructs an ExecTask instance, linked to the current project, for running the client. This
   * implementation prepares the exec task so it will run the appclient script.
   *
   * @return ExecTask initialized for running the appclient script to execute the generated and
   *     retrieved app client
   */
  protected ExecTask prepareRunExecTask() {
    /*
     This is the ant excerpt imitated by the exec task built by this method:

     <exec executable="${APPCLIENT}" resultproperty="result" failonerror="false" output="${build}/${log.id}.output.log">
                <arg line="-client ${archivedir}/${testName}Client.jar"/>
            </exec>
    */
    ExecTask exec = new ExecTask();
    exec.setProject(project);
    String appclientValue = project.getProperty("APPCLIENT");
    exec.setExecutable(appclientValue);
    exec.setFailonerror(false);
    exec.setTaskName("runclient");
    return exec;
  }
 private void executeDotCover(DotcoverStep step, String xmlFile) {
   ExecTask exec = new ExecTask(this);
   exec.setProject(getProject());
   exec.setExecutable(execPath);
   exec.setFailonerror(failOnError);
   exec.setFailIfExecutionFails(failOnError);
   exec.createArg().setValue(step.name().toLowerCase());
   exec.createArg().setValue(xmlFile);
   exec.execute();
 }
Ejemplo n.º 5
0
 /**
  * Sets the command line variables to be used to execute and validates for the required parameters
  *
  * @param varSet variable(name / value list)
  */
 public void execute(VariableSet varSet, Project prj) throws ToolsProcessException {
   String path = null;
   String masterConf = null;
   String confml = null;
   String impl = null;
   String iby = null;
   String keepGoing = "false";
   String report = null;
   String varName;
   String value;
   for (Variable variable : varSet.getVariables()) {
     varName = variable.getName();
     value = variable.getValue();
     if (varName.equals("path")) {
       path = value;
     } else if (varName.equals("master_conf")) {
       masterConf = value;
     } else if (varName.equals("confml")) {
       confml = value;
     } else if (varName.equals("impl")) {
       impl = value;
     } else if (varName.equals("iby")) {
       iby = value;
     } else if (varName.equals("keepgoing")) {
       keepGoing = value;
     } else if (varName.equals("report")) {
       report = value;
     }
   }
   if (path == null || masterConf == null || confml == null || iby == null) {
     throw new ToolsProcessException("Config Tool Parameter missing");
   }
   org.apache.tools.ant.taskdefs.ExecTask task = new org.apache.tools.ant.taskdefs.ExecTask();
   task.setTaskName("Configuration");
   task.setDir(new java.io.File(path));
   task.setExecutable(path + java.io.File.separator + "cli_build.cmd");
   if (keepGoing.equals("false")) {
     task.setFailonerror(true);
   } else {
     task.createArg().setValue("-ignore_errors");
   }
   task.createArg().setValue("-master_conf");
   task.createArg().setValue(masterConf);
   task.createArg().setValue("-impl");
   task.createArg().setValue(impl);
   task.createArg().setValue("-confml");
   task.createArg().setValue(confml);
   task.createArg().setValue("-iby");
   task.createArg().setValue(iby);
   if (report != null) {
     task.createArg().setValue("-report");
     task.createArg().setValue(report);
   }
   task.execute();
 }
Ejemplo n.º 6
0
  /**
   * execute this task.
   *
   * @throws BuildException on error.
   */
  public void execute() throws BuildException {

    checkConfiguration();

    Vector files = getFileList();

    // quick exit if the target is up to date
    if (isUpToDate(files)) {
      return;
    }

    log("Building " + archiveType + ": " + cabFile.getAbsolutePath());

    if (!Os.isFamily("windows")) {
      log("Using listcab/libcabinet", Project.MSG_VERBOSE);

      StringBuffer sb = new StringBuffer();

      Enumeration fileEnum = files.elements();

      while (fileEnum.hasMoreElements()) {
        sb.append(fileEnum.nextElement()).append("\n");
      }
      sb.append("\n").append(cabFile.getAbsolutePath()).append("\n");

      try {
        Process p =
            Execute.launch(
                getProject(),
                new String[] {"listcab"},
                null,
                baseDir != null ? baseDir : getProject().getBaseDir(),
                true);
        OutputStream out = p.getOutputStream();

        // Create the stream pumpers to forward listcab's stdout and stderr to the log
        // note: listcab is an interactive program, and issues prompts for every new line.
        //       Therefore, make it show only with verbose logging turned on.
        LogOutputStream outLog = new LogOutputStream(this, Project.MSG_VERBOSE);
        LogOutputStream errLog = new LogOutputStream(this, Project.MSG_ERR);
        StreamPumper outPump = new StreamPumper(p.getInputStream(), outLog);
        StreamPumper errPump = new StreamPumper(p.getErrorStream(), errLog);

        // Pump streams asynchronously
        (new Thread(outPump)).start();
        (new Thread(errPump)).start();

        out.write(sb.toString().getBytes());
        out.flush();
        out.close();

        // A wild default for when the thread is interrupted
        int result = DEFAULT_RESULT;

        try {
          // Wait for the process to finish
          result = p.waitFor();

          // Wait for the end of output and error streams
          outPump.waitFor();
          outLog.close();
          errPump.waitFor();
          errLog.close();
        } catch (InterruptedException ie) {
          log("Thread interrupted: " + ie);
        }

        // Informative summary message in case of errors
        if (Execute.isFailure(result)) {
          log("Error executing listcab; error code: " + result);
        }
      } catch (IOException ex) {
        String msg = "Problem creating " + cabFile + " " + ex.getMessage();
        throw new BuildException(msg, getLocation());
      }
    } else {
      try {
        File listFile = createListFile(files);
        ExecTask exec = createExec();
        File outFile = null;

        // die if cabarc fails
        exec.setFailonerror(true);
        exec.setDir(baseDir);

        if (!doVerbose) {
          outFile = FILE_UTILS.createTempFile("ant", "", null, true, true);
          exec.setOutput(outFile);
        }

        exec.setExecutable("cabarc");
        exec.createArg().setValue("-r");
        exec.createArg().setValue("-p");

        if (!doCompress) {
          exec.createArg().setValue("-m");
          exec.createArg().setValue("none");
        }

        if (cmdOptions != null) {
          exec.createArg().setLine(cmdOptions);
        }

        exec.createArg().setValue("n");
        exec.createArg().setFile(cabFile);
        exec.createArg().setValue("@" + listFile.getAbsolutePath());

        exec.execute();

        if (outFile != null) {
          outFile.delete();
        }

        listFile.delete();
      } catch (IOException ioe) {
        String msg = "Problem creating " + cabFile + " " + ioe.getMessage();
        throw new BuildException(msg, getLocation());
      }
    }
  }
 /** Default implementation for executing the app client */
 protected void runClient() {
   ExecTask exec = prepareRunExecTask();
   prepareRunCommandlineArg(exec);
   exec.execute();
 }
Ejemplo n.º 8
0
  public void execute() {
    // Make sure we have all the required fields set.
    if (outFile == null) {
      throw new BuildException("The outFile attribute is required");
    }

    // First, populate all of the properties we care about for this task.
    if (getProject().getProperty("ant.build.native.toolchain") != null) {
      this.setToolchain(getProject().getProperty("ant.build.native.toolchain"));
    }

    if (getProject().getProperty("ant.build.native.host") != null) {
      this.setHost(getProject().getProperty("ant.build.native.host"));
    }

    // Setup the compiler.
    LinkerAdapter linker = ToolchainFactory.getLinker(toolchain);
    linker.setProject(getProject());
    linker.setOutFile(outFile);

    if (host != null && host.length() > 0) {
      // Prepend the host string to the executable.
      linker.setExecutable(host + '-' + linker.getExecutable());
    }

    for (AbstractFeature feat : features) {
      if (feat.isIfConditionValid() && feat.isUnlessConditionValid()) {
        linker.addArg(feat);
      }
    }

    long newest = 0;
    Iterator<File> inFile = linker.getInFiles();
    while (inFile.hasNext()) {
      long modified = inFile.next().lastModified();

      if (newest < modified) {
        newest = modified;
      }
    }

    if (newest >= outFile.lastModified()) {
      // Print the executed command.
      Echo echo = (Echo) getProject().createTask("echo");
      echo.setTaskName(this.getTaskName());
      echo.setAppend(true);

      // Create an exec task to run a shell.  Using the current shell to
      // execute commands is required for Windows support.
      ExecTask shell = (ExecTask) getProject().createTask("exec");
      shell.setTaskName(this.getTaskName());
      shell.setFailonerror(true);
      // shell.setDir(dir);

      echo.addText(linker.getExecutable());
      shell.setExecutable(linker.getExecutable());

      Iterator<String> args = linker.getArgs();
      while (args.hasNext()) {
        String arg = args.next();

        echo.addText(" " + arg);
        shell.createArg().setLine(arg);
      }

      echo.execute();
      shell.execute();
    }
  }