I'm wanting to launch the program from a Java application, with some luck. Most programs are started without problems, but some seem to not execute properly(?).
The code I'm using is very simple:
private static void exec() {
ProcessBuilder builder = new ProcessBuilder("C:\\Users\\Fillipuster\\AppData\\Local\\Discord\\Update.exe");
try {
builder.start();
} catch (IOException e) {
e.printStackTrace();
}
}
...and works for almost all executables (*.exe). Discord is purposefully placed in the example, as it is one of the programs that cause this problem. (along with Messenger For Windows and GOG Galaxy).
The behavior is simple, and the same for all executable that causes this; a command prompt quickly pops into existence and then promptly disappears (pun intended) - resulting in the application not being launched.
Sifting through Google and Stack Overflow proved a futile effort, and at this point, I'm at a complete loss.
Any help/input is much appreciated.
Thanks to John, who pointed out that even launching the the Update.exe file "manually" results in the same behavior, I've found the problem.
It seems that when launching Discord successfully, one is actually launching a shortcut that gives a parameter to the executable. In this case:
--processStart Discord.exe
This means that the following code will in fact start Discord:
private static void exec() {
ProcessBuilder builder = new ProcessBuilder("C:\\Users\\Fillipuster\\AppData\\Local\\Discord\\Update.exe", "--processStart", "Discord.exe");
try {
builder.start();
} catch (IOException e) {
e.printStackTrace();
}
}
Thanks to John and all the other commenters.
Related
I am working on a program written in Java which, for some actions, launches external programs using user-configured command lines. Currently it uses Runtime.exec() and does not retain the Process reference (the launched programs are either a text editor or archive utility, so no need for the system in/out/err streams).
There is a minor problem with this though, in that when the Java program exits, it doesn't really quit until all the launched programs are exited.
I would greatly prefer it if the launched programs were completely independent of the JVM which launched them.
The target operating system is multiple, with Windows, Linux and Mac being the minimum, but any GUI system with a JVM is really what is desired (hence the user configurability of the actual command lines).
Does anyone know how to make the launched program execute completely independently of the JVM?
Edit in response to a comment
The launch code is as follows. The code may launch an editor positioned at a specific line and column, or it may launch an archive viewer. Quoted values in the configured command line are treated as ECMA-262 encoded, and are decoded and the quotes stripped to form the desired exec parameter.
The launch occurs on the EDT.
static Throwable launch(String cmd, File fil, int lin, int col) throws Throwable {
String frs[][]={
{ "$FILE$" ,fil.getAbsolutePath().replace('\\','/') },
{ "$LINE$" ,(lin>0 ? Integer.toString(lin) : "") },
{ "$COLUMN$",(col>0 ? Integer.toString(col) : "") },
};
String[] arr; // array of parsed tokens (exec(cmd) does not handle quoted values)
cmd=TextUtil.replace(cmd,frs,true,"$$","$");
arr=(String[])ArrayUtil.removeNulls(TextUtil.stringComponents(cmd,' ',-1,true,true,true));
for(int xa=0; xa<arr.length; xa++) {
if(TextUtil.isQuoted(arr[xa],true)) {
arr[xa]=TextDecode.ecma262(TextUtil.stripQuotes(arr[xa]));
}
}
log.println("Launching: "+cmd);
Runtime.getRuntime().exec(arr);
return null;
}
This appears to be happening only when the program is launched from my IDE. I am closing this question since the problem exists only in my development environment; it is not a problem in production. From the test program in one of the answers, and further testing I have conducted I am satisfied that it is not a problem that will be seen by any user of the program on any platform.
There is a parent child relation between your processes and you have to break that.
For Windows you can try:
Runtime.getRuntime().exec("cmd /c start editor.exe");
For Linux the process seem to run detached anyway, no nohup necessary.
I tried it with gvim, midori and acroread.
import java.io.IOException;
public class Exec {
public static void main(String[] args) {
try {
Runtime.getRuntime().exec("/usr/bin/acroread");
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Finished");
}
}
I think it is not possible to to it with Runtime.exec in a platform independent way.
for POSIX-Compatible system:
Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", "your command"}).waitFor();
I have some observations that may help other people facing similar issue.
When you use Runtime.getRuntime().exec() and then you ignore the java.lang.Process handle you get back (like in the code from original poster), there is a chance that the launched process may hang.
I have faced this issue in Windows environment and traced the problem to the stdout and stderr streams. If the launched application is writing to these streams, and the buffer for these stream fills up then the launched application may appear to hang when it tries to write to the streams. The solutions are:
Capture the Process handle and empty out the streams continually - but if you want to terminate the java application right after launching the process then this is not a feasible solution
Execute the process call as cmd /c <<process>> (this is only for Windows environment).
Suffix the process command and redirect the stdout and stderr streams to nul using 'command > nul 2>&1'
It may help if you post a test section of minimal code needed to reproduce the problem. I tested the following code on Windows and a Linux system.
public class Main {
/**
* #param args the command line arguments
*/
public static void main(String[] args) throws Exception {
Runtime.getRuntime().exec(args[0]);
}
}
And tested with the following on Linux:
java -jar JustForTesting.jar /home/monceaux/Desktop/__TMP/test.sh
where test.sh looks like:
#!/bin/bash
ping -i 20 localhost
as well as this on Linux:
java -jar JustForTesting.jar gedit
And tested this on Windows:
java -jar JustForTesting.jar notepad.exe
All of these launched their intended programs, but the Java application had no problems exiting. I have the following versions of Sun's JVM as reported by java -version :
Windows: 1.6.0_13-b03
Linux: 1.6.0_10-b33
I have not had a chance to test on my Mac yet. Perhaps there is some interaction occuring with other code in your project that may not be clear. You may want to try this test app and see what the results are.
You want to launch the program in the background, and separate it from the parent. I'd consider nohup(1).
I suspect this would require a actual process fork. Basically, the C equivalent of what you want is:
pid_t id = fork();
if(id == 0)
system(command_line);
The problem is you can't do a fork() in pure Java. What I would do is:
Thread t = new Thread(new Runnable()
{
public void run()
{
try
{
Runtime.getRuntime().exec(command);
}
catch(IOException e)
{
// Handle error.
e.printStackTrace();
}
}
});
t.start();
That way the JVM still won't exit, but no GUI and only a limited memory footprint will remain.
I tried everything mentioned here but without success. Main parent Java process can't quit until the quit of subthread even with cmd /c start and redirecting streams tu nul.
Only one reliable solution for me is this:
try {
Runtime.getRuntime().exec("psexec -i cmd /c start cmd.cmd");
}
catch (Exception e) {
// handle it
}
I know that this is not clear, but this small utility from SysInternals is very helpful and proven. Here is the link.
One way I can think of is to use Runtime.addShutdownHook to register a thread that kills off all the processes (you'd need to retain the process objects somewhere of course).
The shutdown hook is only called when the JVM exits so it should work fine.
A little bit of a hack but effective.
I'm currently writing a Java program that can open .exe programs on my PC, like MS Word for example.
I am having a problem though, because Runtime.getRuntime().exec() will only successfully open certain programs. I have used the exact same code for all the programs, but regardless, some programs won't open.
Here is my code for a program I downloaded, Picasa 3:
class picasaHandler implements ActionListener
{
public void actionPerformed(ActionEvent r)
{
try
{
Runtime.getRuntime().exec("cmd /c start Picasa3.exe");
}
catch (IOException t)
{
JOptionPane.showMessageDialog(null,
"Sorry, could not find Picasa 3");
}
}
}
So my question is, why won't Runtime.getRuntime().exec() run all the programs I use it on, and how do I run programs like Picasa 3, that I cannot run at this moment with this method.
I'm guessing that Picasa3.exe is not on your %PATH% anywhere so it doesn't know how to load it. Have you tried specifying the full path to Picasa3.exe?
Runtime.getRuntime().exec("cmd /c \"c:\\program files (x86)\\Google\\Picasa3\\Picasa3.exe\"")
File file=new File("picassa3");
String filename=file.getAbsolutePath(file);
try
{
Runtime.getRuntime().exec(filename);
}
catch (IOException t)
{
JOptionPane.showMessageDialog(null,
"Sorry, could not find the file");
}
Runtime's exec can only start applications that are on the Windows path. Some programs are automatically on the path, while others, like Picasa, is not.
The only work-around for this is to determine the correct path and then launch that application.
This might work for you.
If you want to run a certain program using Runtime.exec(), just add it's installation path to path variable in your System Variables. To find it's installation path, simply right click on it's shortcut and select "Find Target". Then concat that entire address at the end of your path Variable.
I'm building a restarter for my litte program.
The basic idea is to run a process using Runtime.getRuntime().exec, that excecutes the program itself, then running System.exit(0);
this is the code that does the restarting:
Runtime.getRuntime().addShutdownHook(new Thread() {
#Override
public void run() {
try {
Runtime.getRuntime().exec(strList);
} catch (IOException e) {
e.printStackTrace();
}
}
});
// exit
System.exit(0);
Where strList is an String[] that is something like:
{"/bin/bash","-c","java -jar path/to.jar"}
Don't worry about OS portability, the program will be run exclusively on Ubuntu.
The program restarts fine, or at least a new process is running (and continuing to restart itself after a while)
The problem is after restart I loose the console, so i have no idea what is actually happening with the program.
Is there any way to start the new process in "the same window" or any way to access it (maybe by using screen?)?
I want to open file dowloaded from server with default program and wait until edit is completed (to upload changed file on server). I made this in such way:
public void init() {
try {
int fileId = Integer.valueOf(this.getParameter("id"));
System.out.println("Downloading");
String filePath = downloadFile(fileId);
String[] cmd = { "cmd.exe", "/C", "start /wait " + filePath };
System.out.println("Opening");
Process p = Runtime.getRuntime().exec(cmd);
p.waitFor();
System.out.println("Uploading");
uploadFile(filePath, fileId, address, session);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
This is working preety good except the case if file extension is not associated with any program. Windows display dialog for chooseing program and after client make a choice process is ended and file is immediately upload on server. Have any idea how to solve it?
The problem here is that if there is no associated application with the extension, a seperate process is spawned to ask the user what application to use. There is unfortunately, not much you can do from Java, unless you know exactly what application to call, you won't be able to monitor the file editor if it's not associated with the file prior to launch.
This is an OS feature and there's no easy way around it. Depending on the file type, you might want to "guess" what application the user will use and call that directly instead of the command interpreter, but that is very risky and error prone.
Problem is that the same code below is working on other machine with Windows 7. I also use Windows 7, and bat file works well. But if I try to run this bat from code written before, cmd window just blink once and disappear.
s = path + "makeInfomap.bat";
try {
p = run.exec(s);
} catch (Exception e) {
System.out.println(e);
e.printStackTrace();
}
final int exitVal = p.waitFor();
Run don't walk to this link: When Runtime.exec() won't.
It will tell you how to gobble output and error streams and will tell you how to call the OS's command interpreter when doing similar programs (although it is a little out of date).
My guess is that java is calling it fine but that the batch file itself is running in to trouble.
Try adding a 'pause' as the last line of your batch file and see if the batch file's console gives you any usable information.