public static boolean testCommand(
     final Context context,
     final String command,
     final String contains,
     final List<String> arguments) {
   try {
     final List<String> commandAndArgs = new ArrayList<String>();
     commandAndArgs.add(command);
     commandAndArgs.addAll(arguments);
     final ProcessBuilder pb = new ProcessBuilder(commandAndArgs);
     logCommand(context, pb);
     final Process compilation = pb.start();
     final ConsumeStream result = ConsumeStream.start(compilation.getInputStream(), null);
     final ConsumeStream error = ConsumeStream.start(compilation.getErrorStream(), null);
     compilation.waitFor();
     result.join();
     error.join();
     return error.output.toString().contains(contains)
         || result.output.toString().contains(contains);
   } catch (IOException ex) {
     context.log(ex.getMessage());
     return false;
   } catch (InterruptedException ex) {
     context.log(ex.getMessage());
     return false;
   }
 }
 public static Either<CommandResult> runCommand(
     final Context context, final String command, final File path, final List<String> arguments) {
   try {
     final List<String> commandAndArgs = new ArrayList<String>();
     commandAndArgs.add(command);
     commandAndArgs.addAll(arguments);
     final ProcessBuilder pb = new ProcessBuilder(commandAndArgs);
     if (path != null) {
       pb.directory(path);
     }
     logCommand(context, pb);
     final Process compilation = pb.start();
     final ConsumeStream result = ConsumeStream.start(compilation.getInputStream(), context);
     final ConsumeStream error = ConsumeStream.start(compilation.getErrorStream(), context);
     final int exitCode = compilation.waitFor();
     result.join();
     error.join();
     if (result.exception != null) {
       return Either.fail(result.exception);
     }
     if (error.exception != null) {
       return Either.fail(error.exception);
     }
     return Either.success(
         new CommandResult(result.output.toString(), error.output.toString(), exitCode));
   } catch (IOException ex) {
     return Either.fail(ex);
   } catch (InterruptedException ex) {
     return Either.fail(ex);
   }
 }
  public static String test123() {
    String r = "";

    try {
      // System.setSecurityManager(null);

      // String[] callArgs = {"mkdir", "/home/alexis/test123"};
      String[] callArgs = {"ls"};
      ProcessBuilder pb = new ProcessBuilder(callArgs);
      pb.redirectErrorStream(true);
      Process p = pb.start();
      p.waitFor();

      // BufferedReader br = new BufferedReader(new InputStreamReader(p.getErrorStream() ));
      BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
      String line = "";
      System.out.println("Start Output");
      while ((line = br.readLine()) != null) r += line + "\n";
      System.out.println("End Output");

      /*Process p = Runtime.getRuntime().exec(callArgs);
      p.waitFor();
      System.out.println("Test Complete");*/
      r = line;
    } catch (IOException e) {
      System.out.println(e);
      r = "Test failed";
    } catch (Exception e) {
    }

    return r;
  }
  private void startupProcess(boolean restart) throws IOException {
    if (myIsShuttingDown) {
      return;
    }
    if (ShutDownTracker.isShutdownHookRunning()) {
      myIsShuttingDown = true;
      return;
    }

    if (myStartAttemptCount++ > MAX_PROCESS_LAUNCH_ATTEMPT_COUNT) {
      notifyOnFailure(ApplicationBundle.message("watcher.failed.to.start"), null);
      return;
    }

    if (restart) {
      shutdownProcess();
    }

    LOG.info("Starting file watcher: " + myExecutable);
    ProcessBuilder processBuilder = new ProcessBuilder(myExecutable.getAbsolutePath());
    Process process = processBuilder.start();
    myProcessHandler = new MyProcessHandler(process);
    myProcessHandler.addProcessListener(new MyProcessAdapter());
    myProcessHandler.startNotify();

    if (restart) {
      List<String> recursive = myRecursiveWatchRoots;
      List<String> flat = myFlatWatchRoots;
      if (recursive.size() + flat.size() > 0) {
        setWatchRoots(recursive, flat, true);
      }
    }
  }
Exemple #5
0
  /** Run new Maven os process with given arguments and commands. */
  public void execute() {
    Process process = null;
    BufferedReader br = null;
    try {
      ProcessBuilder processBuilder = getProcessBuilder();
      processBuilder.redirectErrorStream(true);
      log.info("Starting process: " + processBuilder.command());

      process = processBuilder.start();

      // Read output
      br = new BufferedReader(new InputStreamReader(process.getInputStream()));
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }

      process.waitFor();
    } catch (Exception e) {
      throw new RuntimeException(e);
    } finally {
      close(br);
      destroyProcess(process);
    }
  }
Exemple #6
0
 private void setExecutablePermissions(File gradleHome) {
   if (isWindows()) {
     return;
   }
   File gradleCommand = new File(gradleHome, "bin/gradle");
   String errorMessage = null;
   try {
     ProcessBuilder pb = new ProcessBuilder("chmod", "755", gradleCommand.getCanonicalPath());
     Process p = pb.start();
     if (p.waitFor() == 0) {
       System.out.println("Set executable permissions for: " + gradleCommand.getAbsolutePath());
     } else {
       BufferedReader is = new BufferedReader(new InputStreamReader(p.getInputStream()));
       Formatter stdout = new Formatter();
       String line;
       while ((line = is.readLine()) != null) {
         stdout.format("%s%n", line);
       }
       errorMessage = stdout.toString();
     }
   } catch (IOException e) {
     errorMessage = e.getMessage();
   } catch (InterruptedException e) {
     errorMessage = e.getMessage();
   }
   if (errorMessage != null) {
     System.out.println(
         "Could not set executable permissions for: " + gradleCommand.getAbsolutePath());
     System.out.println("Please do this manually if you want to use the Gradle UI.");
   }
 }
  public Process createProcess() throws ExecutionException {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Executing [" + getCommandLineString() + "]");
    }

    List<String> commands;
    try {
      checkWorkingDirectory();

      if (StringUtil.isEmptyOrSpaces(myExePath)) {
        throw new ExecutionException(
            IdeBundle.message("run.configuration.error.executable.not.specified"));
      }

      commands = CommandLineUtil.toCommandLine(myExePath, myProgramParams.getList());
    } catch (ExecutionException e) {
      LOG.warn(e);
      throw e;
    }

    try {
      ProcessBuilder builder = new ProcessBuilder(commands);
      setupEnvironment(builder.environment());
      builder.directory(myWorkDirectory);
      builder.redirectErrorStream(myRedirectErrorStream);
      return builder.start();
    } catch (IOException e) {
      LOG.warn(e);
      throw new ProcessNotCreatedException(e.getMessage(), e, this);
    }
  }
  private void initLogstash(String testName) {

    initLogstashHost();

    String pathToLogstash =
        SGTestHelper.getSGTestRootDir().replace("\\", "/") + "/src/main/resources/logstash";
    String confFilePath = pathToLogstash + "/logstash-shipper-client.conf";
    String fixedTestName = testName.substring(0, testName.length() - 2);
    String backupFilePath = pathToLogstash + "/logstash-shipper-client-" + fixedTestName + ".conf";

    if (process == null) {

      try {

        LogUtils.log("copying file " + confFilePath + " to " + backupFilePath);
        IOUtils.copyFile(confFilePath, backupFilePath);
        //                backupFilePath = IOUtils.backupFile(confFilePath);
        IOUtils.replaceTextInFile(
            backupFilePath,
            "<path_to_test_folder>",
            SGTestHelper.getSGTestRootDir().replace("\\", "/")
                + "/../"
                + suiteName
                + "/"
                + testName);
        IOUtils.replaceTextInFile(backupFilePath, "<suite_name>", suiteName);
        IOUtils.replaceTextInFile(backupFilePath, "<test_name>", testName);
        IOUtils.replaceTextInFile(backupFilePath, "<build_number>", buildNumber);
        IOUtils.replaceTextInFile(backupFilePath, "<version>", version);
        IOUtils.replaceTextInFile(backupFilePath, "<host>", logstashHost);

        String logstashJarPath =
            DeploymentUtils.getLocalRepository() + "net/logstash/1.2.2/logstash-1.2.2.jar";
        logstashLogPath = pathToLogstash + "/logstash-" + fixedTestName + ".txt";
        String cmdLine =
            "java -jar "
                + logstashJarPath
                + " agent -f "
                + backupFilePath
                + " -l "
                + logstashLogPath;

        final String[] parts = cmdLine.split(" ");
        final ProcessBuilder pb = new ProcessBuilder(parts);
        LogUtils.log("Executing Command line: " + cmdLine);

        TimeUnit.SECONDS.sleep(1);
        process = pb.start();

      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
 String confValue(String name, List<String> extraPaths, boolean daemon) {
   // The original code from python started a process that started a jvm
   // with backtype.storm.command.config_value main method that would
   // read the conf value and print it out to an output stream. python
   // tapped on to the output stream of that subprocess and returned the
   // confvalue for the name. Because the pythong code has been shipped
   // to java now it should not spawn a new process which is a jvm since
   // we are already in jvm. Instead it should just be doing as the code
   // commeneted below.
   // However looking at the pythong code it was
   // starting a jvm with -cp argument that had classpaths which might
   // not be available to this java process. Hence there is a chance
   // that the below code might break existing scripts. As a result I
   // have decided to still spawn a new process from java just like
   // python with similar classpaths being constructed for the jvm
   // execution
   /*IFn fn = Utils.loadClojureFn("backtype.storm.config",
           "read-storm-config");
   Object o = fn.invoke();
   return ((Map) o).get(name).toString();*/
   String confValue = "";
   ProcessBuilder processBuilder =
       new ProcessBuilder(
           this.javaCommand,
           "-client",
           this.getConfigOptions(),
           "-Dstorm.conf.file=" + this.configFile,
           "-cp",
           this.getClassPath(extraPaths, daemon),
           "backtype.storm.command.config_value",
           name);
   BufferedReader br;
   try {
     Process process = processBuilder.start();
     br =
         new BufferedReader(
             new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8));
     process.waitFor();
     String line;
     while ((line = br.readLine()) != null) {
       String[] tokens = line.split(" ");
       if ("VALUE:".equals(tokens[0])) {
         confValue = StringUtils.join(Arrays.copyOfRange(tokens, 1, tokens.length), " ");
         break;
       }
     }
     br.close();
   } catch (Exception ex) {
     System.out.println(
         "Exception occured while starting process via " + "processbuilder " + ex.getMessage());
   }
   return confValue;
 }
 @Override
 public Object apply(List<Object> args, Context context) throws ParseException {
   File outFile = null;
   String editor = getEditor();
   try {
     outFile = File.createTempFile("stellar_shell", "out");
     if (args.size() > 0) {
       String arg = (String) args.get(0);
       try (PrintWriter pw = new PrintWriter(outFile)) {
         IOUtils.write(arg, pw);
       }
     }
   } catch (IOException e) {
     String message = "Unable to create temp file: " + e.getMessage();
     LOG.error(message, e);
     throw new IllegalStateException(message, e);
   }
   Optional<Object> console = context.getCapability(CONSOLE, false);
   try {
     PausableInput.INSTANCE.pause();
     // shut down the IO for the console
     ProcessBuilder processBuilder = new ProcessBuilder(editor, outFile.getAbsolutePath());
     processBuilder.redirectInput(ProcessBuilder.Redirect.INHERIT);
     processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
     processBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
     try {
       Process p = processBuilder.start();
       // wait for termination.
       p.waitFor();
       try (BufferedReader br = new BufferedReader(new FileReader(outFile))) {
         String ret = IOUtils.toString(br).trim();
         return ret;
       }
     } catch (Exception e) {
       String message = "Unable to read output: " + e.getMessage();
       LOG.error(message, e);
       return null;
     }
   } finally {
     try {
       PausableInput.INSTANCE.unpause();
       if (console.isPresent()) {
         ((Console) console.get()).pushToInputStream("\b\n");
       }
     } catch (IOException e) {
       LOG.error("Unable to unpause: " + e.getMessage(), e);
     }
     if (outFile.exists()) {
       outFile.delete();
     }
   }
 }
 void executeStormClass(
     String className,
     String jvmType,
     List<String> jvmOptions,
     List<String> extraJars,
     List<String> args,
     boolean fork,
     boolean daemon,
     String daemonName) {
   List<String> extraPaths = new ArrayList<>();
   extraPaths.add(this.clusterConfDirectory);
   String stormLogDirectory = this.confValue("storm.log.dir", extraPaths, daemon);
   if ((stormLogDirectory == null)
       || ("".equals(stormLogDirectory))
       || ("nil".equals(stormLogDirectory))) {
     stormLogDirectory = this.stormHomeDirectory + this.fileSeparator + "logs";
   }
   List<String> commandList = new ArrayList<String>();
   commandList.add(this.javaCommand);
   commandList.add(jvmType);
   commandList.add("-Ddaemon.name=" + daemonName);
   commandList.add(this.getConfigOptions());
   commandList.add("-Dstorm.home=" + this.stormHomeDirectory);
   commandList.add("-Dstorm.log.dir=" + stormLogDirectory);
   commandList.add(
       "-Djava.library.path=" + this.confValue("java.library.path", extraJars, daemon));
   commandList.add("-Dstorm.conf.file=" + this.configFile);
   commandList.add("-cp");
   commandList.add(this.getClassPath(extraJars, daemon));
   commandList.addAll(jvmOptions);
   commandList.add(className);
   commandList.addAll(args);
   ProcessBuilder processBuilder = new ProcessBuilder(commandList);
   processBuilder.inheritIO();
   try {
     Process process = processBuilder.start();
     System.out.println("Executing the command: ");
     String commandLine = StringUtils.join(commandList, " ");
     System.out.println(commandLine);
     if (daemon == true) {
       Runtime.getRuntime().addShutdownHook(new ShutdownHookThread(process, commandLine));
     }
     System.out.println("Waiting for subprocess to finish");
     process.waitFor();
     System.out.println("subprocess finished");
     System.out.println("Exit value from subprocess is :" + process.exitValue());
   } catch (Exception ex) {
     System.out.println(
         "Exception occured while starting process via " + "processbuilder " + ex.getMessage());
   }
 }
Exemple #12
0
  public void restartApplication() {

    try {

      final String javaBin =
          System.getProperty("java.home") + File.separator + "bin" + File.separator + "javaw";
      final File currentJar =
          new File(network.class.getProtectionDomain().getCodeSource().getLocation().toURI());

      System.out.println("javaBin " + javaBin);
      System.out.println("currentJar " + currentJar);
      System.out.println("currentJar.getPath() " + currentJar.getPath());

      /* is it a jar file? */
      // if(!currentJar.getName().endsWith(".jar")){return;}

      try {

        // xmining = 0;
        // systemx.shutdown();

      } catch (Exception e) {
        e.printStackTrace();
      }

      /* Build command: java -jar application.jar */
      final ArrayList<String> command = new ArrayList<String>();
      command.add(javaBin);
      command.add("-jar");
      command.add("-Xms256m");
      command.add("-Xmx1024m");
      command.add(currentJar.getPath());

      final ProcessBuilder builder = new ProcessBuilder(command);
      builder.start();

      // try{Thread.sleep(10000);} catch (InterruptedException e){}

      // close and exit
      SystemTray.getSystemTray().remove(network.icon);
      System.exit(0);

    } // try
    catch (Exception e) {
      JOptionPane.showMessageDialog(null, e.getCause());
    }
  } // ******************************
Exemple #13
0
 private void executeProcess(ProcessBuilder pb) {
   final CyclicBarrier barrier = new CyclicBarrier(3);
   try {
     Process p = pb.start();
     copyStream(p.getErrorStream(), System.err, barrier);
     copyStream(p.getInputStream(), System.out, barrier);
     p.waitFor();
   } catch (IOException e) {
     e.printStackTrace();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
   try {
     barrier.await();
   } catch (InterruptedException e) {
   } catch (BrokenBarrierException e) {
   }
 }
  private Process openMediaFile_inLinux(MediaFile mf) {
    ProcessBuilder p;
    List<String> path = new ArrayList<String>();
    path.add("vlc");

    if (mf.isMediaType(TypeX.MEDIA_DIR)
        && mf.isDirContainsType(TypeX.VIDEO)) // open videos in queue
    {
      MediaFile[] medFold = mf.listMediaFiles();

      for (MediaFile f : medFold) {

        if (f.isMediaType(TypeX.VIDEO)) {
          path.add(f.getAbsoluteFilePath());
        }
      }
    } else if (mf.isMediaType(TypeX.VIDEO)) {
      path.add(mf.getAbsoluteFilePath());
    }

    if (mf.isMediaType(TypeX.MEDIA_DIR) && !mf.isDirContainsType(TypeX.VIDEO)) {
      System.out.println("******Can't open none video files****");
      for (MediaFile f : mf.listMediaFiles()) {

        System.out.println("" + f.getName());
      }
      return null;
    } else if (!mf.isMediaType(TypeX.MEDIA_DIR) && !mf.isMediaType(TypeX.VIDEO)) {
      System.out.println("******Can't open none video files****");
      System.out.println("" + mf.getName());
      return null;
    }

    p = new ProcessBuilder(path);

    try {

      return p.start();
    } catch (IOException e) {
      System.out.println("Runtime error : " + e);
      return null;
    }
  }
Exemple #15
0
 private void startProcess(List<String> command) {
   ProcessBuilder processBuilder = new ProcessBuilder(command);
   DarkMod darkMod = DarkMod.getInstance();
   DarkModUI ui = darkMod.getUI();
   try {
     if (ui != null) {
       ui.setVisible(false);
       ui.dispose();
     }
     Process process = processBuilder.start();
     StreamRedirectFactory.createInputToOutputRedirect(process.getInputStream(), System.out);
     StreamRedirectFactory.createInputToOutputRedirect(process.getErrorStream(), System.err);
     StreamRedirectFactory.createInputToOutputRedirect(System.in, process.getOutputStream());
     System.exit(process.waitFor());
   } catch (Exception exception) {
     exception.printStackTrace();
     System.exit(-1);
   }
 }
  public static void main(String args[]) throws InterruptedException, IOException {
    List<String> command = new ArrayList<String>();
    command.add(System.getenv("windir") + "\\system32\\" + "tree.com");
    command.add("/A");

    ProcessBuilder builder = new ProcessBuilder(command);
    Map<String, String> environ = builder.environment();
    builder.directory(new File(System.getenv("temp")));

    System.out.println("Directory : " + System.getenv("temp"));
    final Process process = builder.start();
    InputStream is = process.getInputStream();
    InputStreamReader isr = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);
    String line;
    while ((line = br.readLine()) != null) {
      System.out.println(line);
    }
    System.out.println("Program terminated!");
  }
  private void startProcess() throws IOException, SrvrMgrException {
    ProcessBuilder builder = new ProcessBuilder(runTimeCommand);
    this.lastCommandDate = System.currentTimeMillis();
    try {
      builder.redirectErrorStream(true);
      this.process = builder.start();
    } catch (Exception ex) {
      throw new SrvrMgrException("Can't start process " + Arrays.toString(runTimeCommand));
    }
    this.locked = false;
    this.processInput = new BufferedWriter(new OutputStreamWriter(process.getOutputStream()));
    this.processOutputStream = process.getInputStream();
    this.PID = getProcessId(process);
    /*TODO: debug*/
    processLog(runTimeCommand, "Input Command");

    byte[] inputData = new byte[1024];
    String result = "";
    int numBytes;

    while ((numBytes = readInputStreamWithTimeout(processOutputStream, inputData, 1000)) > 0
        || !result.contains("srvrmgr>")) {
      if (numBytes > 0) result += new String(inputData, StandardCharsets.UTF_8);
      else {
        try {
          Thread.sleep(500);
        } catch (InterruptedException ex) {
        }
      }
      if (result.contains(("Fatal error"))) {
        this.process.destroy();
        throw new SrvrMgrException("Could not open connection to Siebel Gateway configuration");
      }
      //      System.out.println(result);
      inputData = new byte[1024];
    }
    /*TODO: debug*/
    processLog(result, "Output after process creation");
  }
Exemple #18
0
  /**
   * Executes a command as {@code user}. Saves the stdout/stderr in the corresponding fields and
   * returns the return code of the child process.
   *
   * @param cmd The command to execute
   * @param data The data to send to the stdin of the process
   * @param timelimt How many seconds the command can run
   * @param memlimit How many megabytes the command can use
   */
  private int exec(String cmdS, String data, int timelimit, int memlimit) throws Exception {
    ArrayList<String> cmd = new ArrayList<String>(cmdPrefix);
    cmd.add("-m");
    cmd.add("" + memlimit);
    cmd.add("-c");
    cmd.add("" + timelimit);
    cmd.add("-w");
    cmd.add("" + (3 * timelimit + 1));
    cmd.add("-x");
    cmd.add(cmdS);
    String tmp = "";
    for (String cs : cmd) tmp += " \"" + cs + "\"";
    log.fine("exec " + tmp);
    ProcessBuilder pb = new ProcessBuilder(cmd);
    pb.directory(workDir);
    Process p = pb.start();
    OutputStreamWriter writer = new OutputStreamWriter(p.getOutputStream());
    StreamReader rOut = new StreamReader(p.getInputStream());
    StreamReader rErr = new StreamReader(p.getErrorStream());
    rOut.start();
    rErr.start();

    // TODO I think this may block for big tests. Check and Fix.
    // send and receive data "in parallel"
    writer.write(data);
    writer.flush();
    writer.close();
    rOut.join();
    rErr.join();
    stdout = rOut.result;
    stderr = rErr.result;
    if (rOut.exception != null) throw rOut.exception;
    if (rErr.exception != null) throw rErr.exception;

    // log.finer("out: " + stdout);
    // log.finer("err: " + stderr);
    // log.finer("done exec");
    return p.waitFor();
  }
  /**
   * Run command in separated console.
   *
   * @param workFolder Work folder for command.
   * @param args A string array containing the program and its arguments.
   * @return Started process.
   * @throws IOException If failed to start process.
   */
  public static Process openInConsole(@Nullable File workFolder, String... args)
      throws IOException {
    String[] commands = args;

    String cmd = F.concat(Arrays.asList(args), " ");

    if (U.isWindows()) commands = F.asArray("cmd", "/c", String.format("start %s", cmd));

    if (U.isMacOs())
      commands =
          F.asArray(
              "osascript",
              "-e",
              String.format("tell application \"Terminal\" to do script \"%s\"", cmd));

    if (U.isUnix()) commands = F.asArray("xterm", "-sl", "1024", "-geometry", "200x50", "-e", cmd);

    ProcessBuilder pb = new ProcessBuilder(commands);

    if (workFolder != null) pb.directory(workFolder);

    return pb.start();
  }
Exemple #20
0
  private void restartApp() {
    if (!updateThis()) {
      JOptionPane.showMessageDialog(
          getProgressPanel().getParent(),
          "The update has completed successfully, but the control panel "
              + "was unable to restart itself automatically. Please close then "
              + "restart the control panel manually to use the updated version.",
          "Update Completed",
          JOptionPane.WARNING_MESSAGE);
      return;
    }
    String javaBin =
        System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
    try {
      String appPath = FileUtil.getJarFile().getPath();
      String newJarName = _differ.getNewJarName();
      if (!(newJarName == null || appPath.endsWith(newJarName))) {
        appPath = getPathForNewAppName(appPath);
        if (appPath == null) {
          throw new IllegalArgumentException();
        }
      }

      java.util.List<String> command = new ArrayList<String>();
      command.add(javaBin);
      command.add("-jar");
      command.add(FileUtil.getJarFile().getPath());
      command.add("-updateCompleted");

      ProcessBuilder builder = new ProcessBuilder(command);
      builder.start();
      System.exit(0);
    } catch (Exception e) {
      showError("Failed to restart the Control Panel. Please restart manually.");
    }
  }
Exemple #21
0
 public boolean ok(String out, String reference) {
   try {
     File fo = File.createTempFile("homeworkeval", ".out");
     File fr = File.createTempFile("homeworkeval", ".ref");
     log.fine("Running custom validator.");
     save(out, fo);
     save(reference, fr);
     ArrayList<String> c = new ArrayList<String>();
     c.add(command);
     c.add(fo.getPath());
     c.add(fr.getPath());
     ProcessBuilder pb = new ProcessBuilder(c);
     Process p = pb.start();
     int rc = p.waitFor();
     fo.delete();
     fr.delete();
     log.fine("Custom validator " + command + " says " + rc);
     return rc == 0;
   } catch (Exception e) {
     // Assume NOK. Don't propagate info to the client.
     log.finer("exc: " + UtilSrv.describe(e));
     return false;
   }
 }
    // Creates a new thread, runs the program in that thread, and reports any errors as needed.
    private void run(String clazz) {
      try {
        // Makes sure the JVM resets if it's already running.
        if (JVMrunning) kill();

        // Some String constants for java path and OS-specific separators.
        String separator = System.getProperty("file.separator");
        String path = System.getProperty("java.home") + separator + "bin" + separator + "java";

        // Tries to run compiled code.
        ProcessBuilder builder = new ProcessBuilder(path, clazz);

        // Should be good now! Everything past this is on you. Don't mess it up.
        println(
            "Build succeeded on " + java.util.Calendar.getInstance().getTime().toString(), progErr);
        println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", progErr);

        JVM = builder.start();

        // Note that as of right now, there is no support for input. Only output.
        Reader errorReader = new InputStreamReader(JVM.getErrorStream());
        Reader outReader = new InputStreamReader(JVM.getInputStream());
        // Writer inReader = new OutputStreamWriter(JVM.getOutputStream());

        redirectErr = redirectIOStream(errorReader, err);
        redirectOut = redirectIOStream(outReader, out);
        // redirectIn = redirectIOStream(null, inReader);

      } catch (IOException e) {
        // JVM = builder.start() can throw this.
        println("IOException when running the JVM.", progErr);
        e.printStackTrace();
        displayLog();
        return;
      }
    }
Exemple #23
0
  public int compileJava() {
    try {
      //    create new bin directory
      boolean createBin = new File(classPath).mkdir();

      //    create new javac ProcessBuilder
      //      ProcessBuilder pb =
      //      new ProcessBuilder("javac", "-d", classPath, "./" + studentPath + "/*.java");

      ProcessBuilder pbDir = new ProcessBuilder("dir");
      //    Determine current working directory
      File srcAbsPath = new File(sourcePath);
      srcAbsPathName = srcAbsPath.getAbsolutePath();
      System.out.println("Compiler.java line 69 source path: " + sourcePath);
      System.out.println("Compiler.java line 69 source absolute path: " + srcAbsPathName);

      File cwd = pbDir.directory();
      //    debug code - to confirm correct directory
      //    TestTools.dir(cwd);
      //    NB - ProcessBuilder default is to return a null
      //    pointer for the abstract path to indicate that it
      //    is using System.Properties "user.dir", i.e., the
      //    current system working directory; hence the
      //    critical need to handle a NullPointerException.
      //    Also returns a null pointer if the directory
      //    doesn't exist.

      // all this is doing is changing the dir, can we approach this in a different way using a
      // value in our Data Object? -mh
      File nwd = TestTools.cd(cwd, studentPath);

      System.out.println("(Compiler.java line 88)new working directory: " + nwd.toString());
      String studentPathName = nwd.getAbsolutePath();
      File nwdPath = new File(studentPath);
      System.out.println("(Compiler.java line 91)new working directory path: " + studentPathName);
      //    debug code to test new working directory
      //    TestTools.dir(nwd);

      FileFilter filter = new FileFilter() {};

      String[] javaFileList = nwdPath.list(filter);
      //    set up output file
      File outputFile = new File(outputFileName);
      //    System.out.println(outputFileName);
      outputFile.delete();

      for (int k = 0; k < javaFileList.length; k++) {
        try {
          if (filter.accept(nwdPath, javaFileList[k]) == true) {
            System.out.println("COMPILER.JAVA (line 111)  Compiling: " + javaFileList[k]);

            String compilePath =
                "javac" + "-d" + classPath + ".\\" + studentPath + "\\" + javaFileList[k];
            System.out.println("Compiler.java 117 compile path: " + compilePath);
            ProcessBuilder pb =
                // new ProcessBuilder("javac ", "-d", classPath, ".\\" + studentPath + "\\" +
                // javaFileList[k]);
                new ProcessBuilder(compilePath);

            // System.out.println(pb.environment().toString());  <-- THIS IS VERY INTERESTING

            //          Create environment map and set environmental variables
            Map<String, String> env = pb.environment();
            env.clear();
            env.put("PATH", path);
            env.put("CLASSPATH", classPath);
            //          env.put("SOURCEPATH", sourcePath);
            //          env.remove("OTHERVAR");

            pb.redirectErrorStream(true);
            pb.redirectOutput(Redirect.appendTo(outputFile));

            //          start javac process
            Process p = pb.start();

            //          need other processes to wait for compilation to finish
            //          basically joins the thread to the javac process to force sequential
            //          execution - need to be careful - if any process hangs, whole run hangs
            success =
                p
                    .waitFor(); // Returns the exit value of the process. By convention, 0 indicates
                                // normal termination.
                                // http://docs.oracle.com/javase/6/docs/api/java/lang/Process.html#waitFor%28%29

            assert pb.redirectInput() == Redirect.PIPE;
            assert pb.redirectOutput().file() == outputFile;
            assert p.getInputStream().read() == -1;
            System.out.println("COMPILER.JAVA (line 138)  end of loop, success = " + success);
          }
        } catch (Exception e) {
          System.out.println(" Compiler.java FOR LOOP Compile Exception: " + javaFileList[k]);
        }
      }
    } catch (Exception e) {
      System.out.println("Compile Exception, PROBABLY DUE TO FILE PATH");
      System.out.println("source absolute path: " + srcAbsPathName);
    }

    return success;
  }
  private void initLogstash2(ITestResult tr) {

    initLogstashHost();

    String simpleClassName = tr.getTestClass().getRealClass().getSimpleName();
    String pathToLogstash =
        SGTestHelper.getSGTestRootDir().replace("\\", "/") + "/src/main/resources/logstash";
    String confFilePath2 = pathToLogstash + "/logstash-shipper-client-2.conf";
    String backupFilePath2 =
        pathToLogstash + "/logstash-shipper-client-2-" + simpleClassName + ".conf";
    File backupFile2 = new File(backupFilePath2);

    LogUtils.log(
        "trying to start logstash agent number 2. simple class name is " + simpleClassName);
    if (backupFile2.exists()) {
      LogUtils.log("the file " + backupFilePath2 + " already exists. not starting logstash");
    }

    if (!isAfter(tr) && !backupFile2.exists()) {

      try {
        //                backupFilePath2 = IOUtils.backupFile(confFilePath2);
        LogUtils.log("copying file " + confFilePath2 + " to " + backupFilePath2);
        IOUtils.copyFile(confFilePath2, backupFilePath2);
        IOUtils.replaceTextInFile(backupFilePath2, "<path_to_build>", SGTestHelper.getBuildDir());
        IOUtils.replaceTextInFile(
            backupFilePath2,
            "<suite_number>",
            "suite_" + System.getProperty("iTests.suiteId", "0"));
        IOUtils.replaceTextInFile(
            backupFilePath2,
            "<path_to_test_class_folder>",
            SGTestHelper.getSGTestRootDir().replace("\\", "/")
                + "/../"
                + suiteName
                + "/"
                + tr.getTestClass().getName());
        IOUtils.replaceTextInFile(backupFilePath2, "<suite_name>", suiteName);
        IOUtils.replaceTextInFile(backupFilePath2, "<test_name>", simpleClassName);
        IOUtils.replaceTextInFile(backupFilePath2, "<build_number>", buildNumber);
        IOUtils.replaceTextInFile(backupFilePath2, "<version>", version);
        IOUtils.replaceTextInFile(backupFilePath2, "<host>", logstashHost);

        String logstashJarPath =
            DeploymentUtils.getLocalRepository() + "net/logstash/1.2.2/logstash-1.2.2.jar";
        logstashLogPath2 = pathToLogstash + "/logstash-" + simpleClassName + "-2.txt";
        String cmdLine =
            "java -jar "
                + logstashJarPath
                + " agent -f "
                + backupFilePath2
                + " -l "
                + logstashLogPath2;

        final String[] parts = cmdLine.split(" ");
        final ProcessBuilder pb = new ProcessBuilder(parts);
        LogUtils.log("Executing Command line: " + cmdLine);

        process2 = pb.start();

      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
Exemple #25
0
  /** {@inheritDoc} */
  @Override
  @requires("java-runtime>=7")
  public boolean invoke(final String command, final boolean consumed, final Scanner scanner) {
    if (command.equals("help")) {
      if (consumed) return true;
      System.out.println("COMMANDS:     DESCRIPTIONS:");
      System.out.println("help          Leads here...");
      System.out.println("show c        Show copyright notice.");
      System.out.println("show w        Show warranty notice.");
      System.out.println("show l        Show licenses.");
      System.out.println("version       Print version information about this program.");
      System.out.println("credits       Shows the credits of this program and all aktiv plug-ins.");
    } else if (command.equals("show c")) {
      if (consumed) return true;
      System.out.println("Paradis — Ever growing network for parallell and distributed computing.");
      System.out.println("Copyright © 2012  Mattias Andrée");
      System.out.println();
      System.out.println("This program is free software: you can redistribute it and/or modify");
      System.out.println(
          "it under the terms of the GNU Affero General Public License as published by");
      System.out.println("the Free Software Foundation, either version 3 of the License, or");
      System.out.println("(at your option) any later version.");
      System.out.println();
      System.out.println(
          "You should have received a copy of the GNU Affero General Public License");
      System.out.println("along with this program.  If not, see <http://www.gnu.org/licenses/>.");
    } else if (command.equals("show w")) {
      if (consumed) return true;
      System.out.println("This program is distributed in the hope that it will be useful,");
      System.out.println("but WITHOUT ANY WARRANTY; without even the implied warranty of");
      System.out.println("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the");
      System.out.println("GNU Affero General Public License for more details.");
    } else if (command.equals("show l")) {
      if (consumed) return true;
      final String pager = Properties.getPager();

      if (FileHandler.fileExists("res/COPYING+colour"))
        Pager.pageFile(pager, "Copyright information", "res/COPYING+colour");
      else if (FileHandler.fileExists("res/COPYING"))
        Pager.pageFile(pager, "Copyright information", "res/COPYING");
      else Pager.pageFile(pager, "Copyright information", "COPYING");

      if (FileHandler.fileExists("res/LICENSE.AGPL3+colour"))
        Pager.pageFile(pager, "GNU Affero General Public License v3", "res/LICENSE.AGPL3+colour");
      else if (FileHandler.fileExists("res/LICENSE.AGPL3"))
        Pager.pageFile(pager, "GNU Affero General Public License v3", "res/LICENSE.AGPL3");
      else Pager.pageFile(pager, "GNU Affero General Public License v3", "LICENSE.AGPL3");

      if (FileHandler.fileExists("res/LICENSE.GPL3+colour"))
        Pager.pageFile(pager, "GNU General Public License v3", "res/LICENSE.GPL3+colour");
      else if (FileHandler.fileExists("res/LICENSE.GPL3"))
        Pager.pageFile(pager, "GNU General Public License v3", "res/LICENSE.GPL3");
      else Pager.pageFile(pager, "GNU General Public License v3", "LICENSE.GPL3");

      if (FileHandler.fileExists("res/LICENSE.GPL2+colour"))
        Pager.pageFile(pager, "GNU General Public License v2", "res/LICENSE.GPL2+colour");
      else if (FileHandler.fileExists("res/LICENSE.GPL2"))
        Pager.pageFile(pager, "GNU General Public License v2", "res/LICENSE.GPL2");
      else Pager.pageFile(pager, "GNU General Public License v2", "LICENSE.GPL2");
    } else if (command.equals("version")) {
      if (consumed) return true;
      System.out.println("Package:   " + Program.PACKAGE);
      System.out.println("Fork path: " + Program.FORK);
      System.out.println("Version:   " + Program.VERSION);
      System.out.println();
      System.out.println("Website:   " + Program.WEBSITE);
    } else if (command.equals("credits")) {
      if (consumed) return true;
      System.out.println("Paradis — Ever growing network for parallell and distributed computing.");
      System.out.println("Copyright © 2012  Mattias Andrée");
    } else if (command.equals("shell")) {
      if (consumed) return true;
      String shell = Properties.getShell();
      if ((shell == null) || shell.isEmpty())
        System.out.println(
            "Impossible to determine shell, your shell should export SHELL to it's file name (e.g. bash).");
      else
        try {
          final ProcessBuilder builder = new ProcessBuilder(shell);
          builder.inheritIO();
          builder.start().waitFor();
        } catch (final Throwable err) {
          System.out.print("Cannot manage to start shell");
        }
    } else if (command.equals("pacman") || command.startsWith("pacman ")) {
      if (consumed) return true;
      Pacman.main(
          command.equals("pacman")
              ? new String[0]
              : command.substring("pacman ".length()).split(" "));
    } else if (command.equals("makepkg") || command.startsWith("makepkg ")) {
      if (consumed) return true;
      Makepkg.main(
          command.equals("makepkg")
              ? new String[0]
              : command.substring("makepkg ".length()).split(" "));
    } else return false;

    return true;
  }