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;
   }
 }
  /**
   * Executes the command through a system 'exec'. This method will be used only if the supporting
   * Java Native Interface library could not be loaded.
   */
  private synchronized void pure_exec(String[] cmd) throws IOException {
    if (null != this.environ.getExecutable()) {
      cmd[0] = this.environ.getExecutable();
    }
    p = rt.exec(cmd, this.environ.getEnvp());
    InputStream is = p.getInputStream();
    Debug.verbose("P4Process.exec().is: " + is);
    InputStreamReader isr = new InputStreamReader(is);
    Debug.verbose("P4Process.exec().isr: " + isr);
    in = new BufferedReader(isr);
    InputStream es = p.getErrorStream();
    Debug.verbose("P4Process.exec().es: " + es);
    InputStreamReader esr = new InputStreamReader(es);
    Debug.verbose("P4Process.exec().esr: " + esr);
    err = new BufferedReader(esr);

    OutputStream os = p.getOutputStream();
    Debug.verbose("P4Process.exec().os: " + os);
    OutputStreamWriter osw = new OutputStreamWriter(os);
    Debug.verbose("P4Process.exec().osw: " + osw);
    out =
        new FilterWriter(new BufferedWriter(osw)) {
          public void write(String str) throws IOException {
            super.write(str);
            System.out.print("P4DebugOutput: " + str);
          }
        };
  }
 public static TByteArrayList transformByExternalCommand(
     final String command, final InputStream input) throws IOException {
   final Process process = Runtime.getRuntime().exec(command);
   final InputStream in = process.getInputStream();
   final OutputStream out = process.getOutputStream();
   final TByteArrayList bytes = new TByteArrayList(100500);
   final byte[] buffer = new byte[1024 * 1024];
   try {
     int read;
     while ((read = input.read(buffer)) > 0) {
       out.write(buffer, 0, read);
       if (in.available() > 0) {
         read = in.read(buffer);
         bytes.add(buffer, 0, read);
       }
     }
     out.close();
     while ((read = in.read(buffer)) > 0) {
       bytes.add(buffer, 0, read);
     }
     in.close();
   } catch (IOException ioe) {
     System.err.println(readByteStream(process.getErrorStream()));
     LOG.error(ioe);
     throw ioe;
   }
   return bytes;
 }
Exemple #4
0
 public String execRecognizer() {
   try {
     String inputFile = new File(tmpdir, "input").getAbsolutePath();
     String[] args =
         new String[] {"java", "-classpath", tmpdir + pathSep + CLASSPATH, "Test", inputFile};
     // String cmdLine = "java -classpath "+CLASSPATH+pathSep+tmpdir+" Test " + new File(tmpdir,
     // "input").getAbsolutePath();
     // System.out.println("execParser: "+cmdLine);
     Process process = Runtime.getRuntime().exec(args, null, new File(tmpdir));
     StreamVacuum stdoutVacuum = new StreamVacuum(process.getInputStream());
     StreamVacuum stderrVacuum = new StreamVacuum(process.getErrorStream());
     stdoutVacuum.start();
     stderrVacuum.start();
     process.waitFor();
     stdoutVacuum.join();
     stderrVacuum.join();
     String output = null;
     output = stdoutVacuum.toString();
     if (stderrVacuum.toString().length() > 0) {
       this.stderrDuringParse = stderrVacuum.toString();
       System.err.println("exec stderrVacuum: " + stderrVacuum);
     }
     return output;
   } catch (Exception e) {
     System.err.println("can't exec recognizer");
     e.printStackTrace(System.err);
   }
   return null;
 }
Exemple #5
0
  public boolean executeFilter(@NotNull Editor editor, @NotNull TextRange range, String command)
      throws IOException {
    if (logger.isDebugEnabled()) logger.debug("command=" + command);
    CharSequence chars = editor.getDocument().getCharsSequence();
    StringReader car =
        new StringReader(
            chars.subSequence(range.getStartOffset(), range.getEndOffset()).toString());
    StringWriter sw = new StringWriter();

    logger.debug("about to create filter");
    Process filter = Runtime.getRuntime().exec(command);
    logger.debug("filter created");
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(filter.getOutputStream()));
    logger.debug("sending text");
    copy(car, writer);
    writer.close();
    logger.debug("sent");

    BufferedReader reader = new BufferedReader(new InputStreamReader(filter.getInputStream()));
    logger.debug("getting result");
    copy(reader, sw);
    sw.close();
    logger.debug("received");

    editor.getDocument().replaceString(range.getStartOffset(), range.getEndOffset(), sw.toString());

    lastCommand = command;

    return true;
  }
  /**
   * Creates a transcoded input stream by executing the given command. If <code>in</code> is not
   * null, data from it is copied to the command.
   *
   * @param command The command to execute.
   * @param in Data to feed to the command. May be <code>null</code>.
   * @throws IOException If an I/O error occurs.
   */
  public TranscodeInputStream(String[] command, final InputStream in) throws IOException {

    StringBuffer buf = new StringBuffer("Starting transcoder: ");
    for (String s : command) {
      buf.append('[').append(s).append("] ");
    }
    LOG.debug(buf);

    process = Runtime.getRuntime().exec(command);
    processOutputStream = process.getOutputStream();
    processInputStream = process.getInputStream();

    // Must read stderr from the process, otherwise it may block.
    final String name = command[0];
    new InputStreamReaderThread(process.getErrorStream(), name, true).start();

    // Copy data in a separate thread
    if (in != null) {
      new Thread(name + " TranscodedInputStream copy thread") {
        public void run() {
          try {
            IOUtils.copy(in, processOutputStream);
          } catch (IOException x) {
            // Intentionally ignored. Will happen if the remote player closes the stream.
          } finally {
            IOUtils.closeQuietly(in);
            IOUtils.closeQuietly(processOutputStream);
          }
        }
      }.start();
    }
  }
Exemple #7
0
  /**
   * System command. Execute a command and insert the result.
   *
   * @param args
   * @param help
   * @param patterns
   * @param low
   * @param high
   */
  public String system_internal(boolean allowFail, String args[]) throws Exception {
    verifyCommand(
        args,
        "${"
            + (allowFail ? "system-allow-fail" : "system")
            + ";<command>[;<in>]}, execute a system command",
        null,
        2,
        3);
    String command = args[1];
    String input = null;

    if (args.length > 2) {
      input = args[2];
    }

    Process process = Runtime.getRuntime().exec(command, null, domain.getBase());
    if (input != null) {
      process.getOutputStream().write(input.getBytes("UTF-8"));
    }
    process.getOutputStream().close();

    String s = IO.collect(process.getInputStream(), "UTF-8");
    int exitValue = process.waitFor();
    if (exitValue != 0) return exitValue + "";

    if (!allowFail && (exitValue != 0)) {
      domain.error("System command " + command + " failed with " + exitValue);
    }
    return s.trim();
  }
  /**
   * ======================================================================================
   * TESSERACT GRAB TEXT FROM IMAGE
   * ======================================================================================
   */
  public String grabText(String image) throws Exception {
    findAndCropImageFromScreen(image);
    String imageInput =
        screenshotsFolder
            + getScreenshotsCounter()
            + "_"
            + image
            + "_screenshot"
            + getRetryCounter()
            + "_"
            + timeDifferenceStartTest
            + "sec"
            + ".png";
    String[] tesseractCommand = {"tesseract", imageInput, "stdout"};
    String value = "";
    try {
      ProcessBuilder p = new ProcessBuilder(tesseractCommand);
      Process proc = p.start();
      InputStream stdin = proc.getInputStream();
      InputStreamReader isr = new InputStreamReader(stdin);
      BufferedReader br = new BufferedReader(isr);
      String line;
      String[] size = null;
      String[] splitLines;
      while ((line = br.readLine()) != null) {
        value += line;
      }

    } catch (Throwable t) {
      t.printStackTrace();
    }
    return value;
  }
 private String getIPAndroid() {
   String host = "localhost";
   try {
     ProcessBuilder builder = new ProcessBuilder("cmd.exe", "/c", "adb shell netcfg");
     builder.redirectErrorStream(true);
     Process p = builder.start();
     BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
     String line;
     while (true) {
       line = r.readLine();
       if (line == null) {
         break;
       }
       if (line.contains("0x00001043")) {
         //                    wlan0    UP                                192.168.1.79/24
         // 0x00001043 b4:52:7d:c5:8b:69
         int index = line.indexOf("/24");
         line = line.substring(0, index);
         index = line.lastIndexOf(" ");
         host = line.substring(index + 1);
         break;
       }
     }
   } catch (IOException e) {
     e.printStackTrace();
     Notifications.Bus.notify(
         new Notification(
             Constant.GROUND_ID, "Error getIPAndroid", e.toString(), NotificationType.ERROR));
   }
   return host;
 }
Exemple #10
0
  private IdedProtos.Response processRequest(IdedProtos.Request request) {
    try {
      request.writeDelimitedTo(process.getOutputStream());
      process.getOutputStream().flush();

      lock.lock();
      try {
        for (; ; ) {
          if (error != null) {
            throw new RuntimeException(error);
          }

          if (response != null) {
            IdedProtos.Response response = this.response;
            this.response = null;
            return response;
          }

          condition.await();
        }
      } finally {
        lock.unlock();
      }

    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
 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);
   }
 }
Exemple #12
0
  /* Heck there's no getenv, we have to roll one ourselves! */
  public static Hashtable getenv() throws Throwable {
    Process p;
    if (File.separator.equals("\\")) {
      p = Runtime.getRuntime().exec("cmd /c set");
    } else {
      p = Runtime.getRuntime().exec("printenv");
    }

    InputStream in = p.getInputStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    String line;
    Hashtable table = new Hashtable();

    while ((line = reader.readLine()) != null) {
      int i = line.indexOf('=');
      if (i > 0) {
        String name = line.substring(0, i);
        String value = line.substring(i + 1);
        table.put(name, value);
      }
    }

    in.close();
    p.waitFor();
    return table;
  }
 public static int runA2sd(int mode) {
   String command = "";
   if (mode == 0) // remove a2sd
   command = "echo \"n\" | /system/bin/a2sd remove";
   else if (mode == 1) // a2sd
   command = "echo \"n\" | /system/bin/a2sd install";
   else if (mode == 2) // dc2sd
   command = "echo \"y\" | /system/bin/a2sd install";
   if (!command.equals("")) {
     try {
       Process process = Runtime.getRuntime().exec("su");
       Log.e(TAG, "Executing: " + command);
       DataOutputStream outputStream = new DataOutputStream(process.getOutputStream());
       DataInputStream inputStream = new DataInputStream(process.getInputStream());
       outputStream.writeBytes(command + "\n");
       outputStream.flush();
       outputStream.writeBytes("exit\n");
       outputStream.flush();
       process.waitFor();
     } catch (IOException e) {
       return -1;
     } catch (InterruptedException e) {
       return -2;
     }
     return 0;
   }
   return -3;
 }
Exemple #14
0
  // function to do the join use case
  public static void share() throws Exception {
    HttpPost method = new HttpPost(url + "/share");
    String ipAddress = null;

    Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
    while (en.hasMoreElements()) {
      NetworkInterface ni = (NetworkInterface) en.nextElement();
      if (ni.getName().equals("eth0")) {
        Enumeration<InetAddress> en2 = ni.getInetAddresses();
        while (en2.hasMoreElements()) {
          InetAddress ip = (InetAddress) en2.nextElement();
          if (ip instanceof Inet4Address) {
            ipAddress = ip.getHostAddress();
            break;
          }
        }
        break;
      }
    }

    method.setEntity(new StringEntity(username + ';' + ipAddress, "UTF-8"));
    try {
      ResponseHandler<String> responseHandler = new BasicResponseHandler();
      connIp = client.execute(method, responseHandler);
    } catch (IOException e) {
      System.err.println("Fatal transport error: " + e.getMessage());
      e.printStackTrace();
    }

    // get present time
    date = new Date();
    long start = date.getTime();

    // Execute the vishwa share process
    Process p = Runtime.getRuntime().exec("java -jar vishwa/JVishwa.jar " + connIp);

    String ch = "alive";
    System.out.println("Type kill to unjoin from the grid");

    while (!ch.equals("kill")) {
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      ch = in.readLine();
    }

    p.destroy();

    date = new Date();
    long end = date.getTime();
    long durationInt = end - start;

    String duration = String.valueOf(durationInt);
    method = new HttpPost(url + "/shareAck");
    method.setEntity(new StringEntity(username + ";" + duration, "UTF-8"));
    try {
      client.execute(method);
    } catch (IOException e) {
      System.err.println("Fatal transport error: " + e.getMessage());
      e.printStackTrace();
    }
  }
  public static void command(String command) {
    boolean err = false;

    try {
      Process process = new ProcessBuilder(command.split(" ")).start();
      BufferedReader results = new BufferedReader(new InputStreamReader(process.getInputStream()));

      String s;
      while ((s = results.readLine()) != null) {
        System.out.println(s);
      }

      BufferedReader errors = new BufferedReader(new InputStreamReader(process.getErrorStream()));

      while ((s = errors.readLine()) != null) {
        System.err.println(s);
        err = true;
      }
    } catch (IOException e) {
      // TODO 自动生成的 catch 块
      e.printStackTrace();
    }

    if (err) {
      throw new OSExecuteException("Errors executing " + command);
    }
  }
Exemple #16
0
 /** Redirect a VMs output and error streams to System.out and System.err */
 protected void redirectStreams(VirtualMachine vm) {
   MessageSiphon ms = new MessageSiphon(process.getErrorStream(), this);
   errThread = ms.getThread();
   outThread = new StreamRedirectThread("VM output reader", process.getInputStream(), System.out);
   errThread.start();
   outThread.start();
 }
  // Uses adb commands to tap at relative coordinates. To be used when appium methods fail. Only
  // works on Android devices.
  public void tapAtRelativeCoordinatesADB(double x_offset, double y_offset) throws Exception {
    if (platformName.equalsIgnoreCase("iOS")) {
      tapAtRelativeCoordinates(x_offset, y_offset);
    } else {
      Dimension size = getScreenSizeADB();
      log("Size of device as seen by ADB is - width: " + size.width + " height: " + size.height);
      String x = String.valueOf(size.width * x_offset);
      String y = String.valueOf(size.height * y_offset);
      log("ADB: x and y: " + x + ", " + y);
      String[] adbCommand = {"adb", "shell", "input", "tap", x, y};
      //            String[] adbCommand = {"adb", "shell", "input", "touchscreen", "swipe", x, y, x,
      // y, "2000"};

      try {
        ProcessBuilder p = new ProcessBuilder(adbCommand);
        Process proc = p.start();
        InputStream stdin = proc.getInputStream();
        InputStreamReader isr = new InputStreamReader(stdin);
        BufferedReader br = new BufferedReader(isr);
        String line = null;
        while ((line = br.readLine()) != null) System.out.print(line);

        proc.waitFor();

      } catch (Throwable t) {
        t.printStackTrace();
      }
    }
  }
  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;
  }
 public boolean findDeviceTypeADB() throws Exception {
   log("trying to find device type ...");
   log("------------------------------");
   if (platformName.equalsIgnoreCase("iOS")) {
     // TO Be added
   } else {
     String adb = "adb";
     String[] adbCommand = {adb, "shell", "getprop", "ro.build.characteristics"};
     try {
       ProcessBuilder p = new ProcessBuilder(adbCommand);
       Process proc = p.start();
       InputStream stdin = proc.getInputStream();
       InputStreamReader isr = new InputStreamReader(stdin);
       BufferedReader br = new BufferedReader(isr);
       String line = null;
       String[] size = null;
       while ((line = br.readLine()) != null) {
         if (line.contains("tablet")) {
           return true;
         }
       }
     } catch (Throwable t) {
       t.printStackTrace();
     }
   }
   return false;
 }
  public static void processPSOutput(Process psProcess, Processor<String> processor)
      throws IOException {
    @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed"})
    BufferedReader stdOutput =
        new BufferedReader(new InputStreamReader(psProcess.getInputStream()));
    BufferedReader stdError = new BufferedReader(new InputStreamReader(psProcess.getErrorStream()));

    try {
      String s;
      stdOutput.readLine(); // ps output header
      while ((s = stdOutput.readLine()) != null) {
        processor.process(s);
      }

      StringBuilder errorStr = new StringBuilder();
      while ((s = stdError.readLine()) != null) {
        errorStr.append(s).append("\n");
      }
      if (errorStr.length() > 0) {
        throw new IllegalStateException("error:" + errorStr.toString());
      }
    } finally {
      stdOutput.close();
      stdError.close();
    }
  }
Exemple #21
0
  public static void main(String args[]) {

    try {
      Runtime rt = Runtime.getRuntime();
      // Process pr = rt.exec("cmd /c dir");
      Process pr = rt.exec("python ciao.py");

      BufferedReader input = new BufferedReader(new InputStreamReader(pr.getInputStream()));

      String line = null;

      while ((line = input.readLine()) != null) {
        System.out.println(line);
      }

      int exitVal = pr.waitFor();
      if (exitVal == 0) {
        System.out.println("Exited without errors ");
      } else {
        System.out.println("Exited with error code " + exitVal);
      }

    } catch (Exception e) {
      System.out.println(e.toString());
      e.printStackTrace();
    }
  }
    // 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 (Exception e) {
        // This catches any other errors we might get.
        println("Some error thrown", progErr);
        logError(e.toString());
        displayLog();
        return;
      }
    }
Exemple #23
0
  // Method: runTest
  // Runs the script specified in the test case object
  public void runTest() {
    try {
      Process p = Runtime.getRuntime().exec(this.execCommandLine);

      InputStreamReader esr = new InputStreamReader(p.getErrorStream());
      BufferedReader ereader = new BufferedReader(esr);
      InputStreamReader isr = new InputStreamReader(p.getInputStream());
      BufferedReader ireader = new BufferedReader(isr);

      String line = null;
      String line1 = null;
      while ((line = ireader.readLine()) != null) {
        // System.out.println("Output: " + line);
        System.out.println(line);
      }
      while ((line1 = ereader.readLine()) != null) {
        System.err.println("Error: " + line1);
      }

      int exitValue = p.waitFor();
      tcInstanceTools.LogMessage('d', "Test Case exit value: " + exitValue);
      if (exitValue == 0) {
        setTestCaseResult(Result.Pass);
      } else {
        setTestCaseResult(Result.Fail);
      }
    } catch (IOException ioe) {
      System.out.println("Error: " + ioe.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: " + e.getMessage());
    }
  }
  public static void main(String[] Args) {
    // System.setProperty("KEY", "HNY81514525MALVIYA");
    // Map<String, String> env = System.getenv();
    // for (String envName : env.keySet())
    // System.out.format("%s = %s%n", envName, env.get(envName));

    // reg add HKCU\\Environment /v developer /d \"Honey Keny Malviya" /f"

    try {
      String PERSONAL_FOLDER_CMD = "reg query HKCU\\Environment /v developer";
      String REGSTR_TOKEN = "REG_SZ";
      Process process = Runtime.getRuntime().exec(PERSONAL_FOLDER_CMD);
      StreamReader reader = new StreamReader(process.getInputStream());
      reader.start();
      process.waitFor();
      reader.join();
      String result = reader.getResult();
      int p = result.indexOf(REGSTR_TOKEN);
      if (p == -1) return;
      System.out.println(result.substring(p + REGSTR_TOKEN.length()).trim());
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
  }
  public static int RefreshDatabase() {
    if (ERROR == SendHttp("http://" + HOST + ":" + REST_PORT + "/" + DATABASEINDEX, REQ_DELETE)) {
      System.out.println(PROMPT + "Delete log database index failed!");
      return ERROR;
    }
    if (ERROR == SendHttp("http://" + HOST + ":" + REST_PORT + "/" + DATABASEINDEX, REQ_PUT)) {
      System.out.println(PROMPT + "Create log database index failed!");
      return ERROR;
    }
    // Set mapping manually
    try {
      String cmd =
          "curl -XPUT "
              + HOST
              + ':'
              + REST_PORT
              + "/"
              + DATABASEINDEX
              + '/'
              + DATABASETYPE
              + "/_mapping --data-binary @./data/Log/map.json";
      Process ps = Runtime.getRuntime().exec(cmd);
      ps.waitFor();

      BufferedReader br = new BufferedReader(new InputStreamReader(ps.getInputStream()));
      String line;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }
    } catch (Exception e) {
      e.printStackTrace();
      return ERROR;
    }
    return SUCCESS;
  }
Exemple #26
0
  // ## operation runReactor()
  public void runReactor() {
    // #[ operation runReactor()
    // run reactor
    String dir = System.getProperty("RMG.workingDirectory");

    try {
      // system call for reactor
      String[] command = {dir + "/software/reactorModel/reactor.exe"};
      File runningDir = new File("chemkin");
      Process reactor = Runtime.getRuntime().exec(command, null, runningDir);
      InputStream ips = reactor.getInputStream();
      InputStreamReader is = new InputStreamReader(ips);
      BufferedReader br = new BufferedReader(is);
      String line = null;
      while ((line = br.readLine()) != null) {
        // System.out.println(line);
      }
      int exitValue = reactor.waitFor();
    } catch (Exception e) {
      System.out.println("Error in running reactor!");
      System.out.println(e.getMessage());
      System.exit(0);
    }

    // #]
  }
    public void generateDiagram(String outputDirectory, File dotFile) {
      try {
        Runtime run = Runtime.getRuntime();
        Process pr =
            run.exec(
                "dot "
                    + dotFile.getAbsolutePath()
                    + " -Tpng -o"
                    + outputDirectory
                    + FILE_SEPARATOR
                    + "graph.png");
        pr.waitFor();
        // BufferedReader buf = new BufferedReader(new InputStreamReader(pr.getInputStream()));

        // should the output be really printed?
        //            String line;
        //            while ( ( line = buf.readLine() ) != null )
        //            {
        //                System.out.println(line) ;
        //            }
        // FIXME how to handle exceptions in listener?
      } catch (IOException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (InterruptedException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      }
    }
  /**
   * Gives the same basic functionality of File.exists but can be used to look for removable media
   * without showing a system dialog if the media is not present. Workaround pulled from the <A
   * HREF="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4089199"> bug report</A> on
   * bugs.sun.com. This bug was fixed in Java 6, and we can remove the workaround when we start
   * requiring Java 6.
   */
  protected static boolean fileExists(File file) {
    try {
      Process process =
          Runtime.getRuntime().exec(new String[] {"cmd.exe", "/c", "dir", file.getAbsolutePath()});

      // We need to consume all available output or the process will block.
      boolean haveExitCode = false;
      int exitCode = -1;
      InputStream out = process.getInputStream();
      InputStream err = process.getErrorStream();

      while (!haveExitCode) {
        while (out.read() >= 0) {}
        while (err.read() >= 0) {}

        try {
          exitCode = process.exitValue();
          haveExitCode = true;
        } catch (IllegalThreadStateException e) {
          // Not yet complete.
          Thread.sleep(100);
        }
      }
      // int exitCode = process.waitFor();
      return exitCode == 0;

    } catch (IOException e) {
      System.out.println("Unable to check for file: " + file + " : " + e);
      return false;

    } catch (InterruptedException e) {
      System.out.println("Unable to check for file.  Interrupted: " + file + " : " + e);
      return false;
    }
  }
  /**
   * Gets the token.
   *
   * @param scope the scope
   * @return the token
   */
  private String getToken(String scope) {
    Process curlProc;
    String outputString;
    DataInputStream curlIn = null;
    String access_token = null;
    String command =
        "curl -X POST -H Content-Type:application/x-www-form-urlencoded "
            + adminUrl
            + "/oauth2/token --insecure --data"
            + " client_id="
            + client_id
            + "&"
            + "client_secret="
            + client_secret
            + "&grant_type=client_credentials&scope="
            + scope;
    try {
      curlProc = Runtime.getRuntime().exec(command);

      curlIn = new DataInputStream(curlProc.getInputStream());

      while ((outputString = curlIn.readLine()) != null) {
        JSONObject obj = new JSONObject(outputString);
        access_token = obj.getString("access_token");
      }
    } catch (IOException e1) {
      e1.printStackTrace();
    } catch (JSONException e) {
      e.printStackTrace();
    }
    return access_token;
  }
  public static String execute(String command) {
    StringBuilder sb = new StringBuilder();
    String[] commands =
        new String[] {"/bin/bash", "-c", "export PATH=\"$PATH:/opt/local/bin\"; " + command};
    try {
      Process proc = new ProcessBuilder(commands).start();
      BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));

      BufferedReader stdError = new BufferedReader(new InputStreamReader(proc.getErrorStream()));

      String s = null;
      while ((s = stdInput.readLine()) != null) {
        sb.append(s);
        sb.append("\n");
      }

      while ((s = stdError.readLine()) != null) {
        sb.append(s);
        sb.append("\n");
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
    return sb.toString();
  }