Develop Reference

Executing mv command with Java.exec();

I am trying to move an file via the linux mv command.
I have following code:
processBuilder.command("/bin/sh", "-c", "\"mv", "\"" + rawOutput + "/" + dir + "/build/libs/*\"", "\"" + startDir + "/test.jar\"\"");
During execution it translates to
/bin/sh -c "mv "/home/test/update/Test-test-23afi369890Ajk/build/libs/*" "/home/test/test.jar""
While this command executes perfectly via the command line, it fails during execution of the jar.
Following error is given:
"/home/test/update/Test-test-23afi369890Ajk/build/libs/*": 1: "/home/test/update/Test-test-23afi369890Ajk/build/libs/*": Syntax error: Unterminated quoted string
Thanks in advance!

Here's the shell command you want to execute:
mv /home/test/update/Test-test-23afi369890Ajk/build/libs/* /home/test/test.jar
Here's the Java concatenation that builds this shell command in Java (you should print and copy-paste it to a shell to verify it):
String myCmd = "mv " + rawOutput + "/build/libs/* " + dir + "/test.jar";
Here's how you can run it in a shell:
processBuilder.command("/bin/sh", "-c", myCmd);
This gives the following argument list:
/bin/sh
-c
mv /home/test/update/Test-test-23afi369890Ajk/build/libs/* /home/test/test.jar
And for completeness, here's how you should have designed it, with a static command string and passing in the arguments as separate parameters to avoid shell injection:
String myCmd = "mv \"$1\"/build/libs/* \"$2\"/test.jar";
processBuilder.command("/bin/sh", "-c", myCmd, "_", rawOutput, dir);
Whose argument list is:
/bin/sh
-c
mv "$1"/build/libs/* "$2"/test.jar
_
/home/test/update/Test-test-23afi369890Ajk
/home/test
(the _ becomes $0, i.e. the script's filename for use in error messages and similar)
During execution [my attempt] translates to
/bin/sh -c "mv "/home/test/update/Test-test-23afi369890Ajk/build/libs/*" "/home/test/test.jar""
I don't know how you reached this conclusion. The actual argument list it expands to is:
/bin/sh
-c
"mv
"/home/test/update/Test-test-23afi369890Ajk/build/libs/*"
"/home/test/test.jar""
This corresponds to the following shell command which probably fails with the same error messages as your Java program (if you're not suppressing stderr):
$ /bin/sh -c '"mv' '"/home/test/update/Test-test-23afi369890Ajk/build/libs/*"' '"/home/test/test.jar""'
"/home/test/update/Test-test-23afi369890Ajk/build/libs/*": 1: Syntax error: Unterminated quoted string

/bin/sh -c not working with process builder

I am trying to run the following command via process builder:
ls -lrt my-directory | tail -1
I am using bin/sh -c when passing it in but cannot get it to work any way I try.(my custom directory depends on the function and is passed in as a string)
process builder("/bin/sh", "-c", "ls -lrt ", customDir, " | tail -1");
This gives the contents of the directory I am running the program out of. It's as if I simply typed ls (not even ls -lrt).
Both of
String temp = "ls -lrt " + customDir + " | tail -1";
process builder("/bin/sh ", "-c " temp);
String temp = "ls -lrt " + customDir;
process builder("/bin/sh ", "-c " temp, " | tail -1");
say that the directory doesn't exist even though I know it does. Removing /bin/sh -c simply gives me an error saying it couldn't understand the ls -lrt command which I understand. But I simply have no idea how to get it to produce the actual results I would get if I typed this command in seperately.
edit: the problem is not because of how I am calling process builder. I send the content to another function which calls process builder properly and relays its output.For simplicity, I just said process builder (...) in the examples.

Java Runtime exec() not working

I try to execute a shell command via java like this
if (Program.isPlatformLinux())
{
exec = "/bin/bash -c xdg-open \"" + file.getAbsolutePath() + "\"";
exec2 = "xdg-open \"" + file.getAbsolutePath() + "\"";
System.out.println(exec);
}
else
{
//other code
}
Runtime.getRuntime().exec(exec);
Runtime.getRuntime().exec(exec2);
but nothing happens at all. When I execute this code it prints /bin/bash -c xdg-open "/home/user/Desktop/file.txt" in the console, but does not open the file. I have also tried to call the bash first and then the xdg-open-command, but there is not change.
What's the problem here and how can I solve this?
EDIT: The output of the calling looks like this:
xdg-open "/home/user/Desktop/files/einf in a- und b/allg fil/ref.txt"
xdg-open: unexpected argument 'in'
But this seeems very strange to me - why is the command seperatet before the in even the entire path is set in quotation marks?

Please note that you don't need xdg-open to do this.
You can use the java platform-agnostic Desktop API:
if(Desktop.isDesktopSupported()) {
Desktop.open("/path/to/file.txt");
}
Update
If the standard approach still gives issues, you can pass the parameters as an array since Runtime.exec does not invoke a shell and therefore does not support or allow quoting or escaping:
String program;
if (Program.isPlatformLinux())
{
program = "xdg-open";
} else {
program = "something else";
}
Runtime.getRuntime().exec(new String[]{program, file.getAbsolutePath()});

Redirecs with /bin/bash from Java Runtime exec()

I'm trying to use a redirect in a command executed with the exec()-method of java.lang.Runtime on Ubuntu 14.04
public static void main(String[] args) throws IOException, Exception {
Runtime runtime = Runtime.getRuntime();
String command = "echo bla > bla.txt";
System.out.println("Command : " + command);
Process process = runtime.exec(command);
printLines(" stdout", process.getInputStream());
printLines(" error", process.getErrorStream());
process.waitFor();
System.out.println("ExitValue : " + process.exitValue());
}
private static void printLines(String name, InputStream ins) throws Exception {
try(Stream<String> lines = new BufferedReader(new InputStreamReader(ins)).lines()) {
lines.forEach(line -> System.out.println(name + " : " + line));
}
}
The output is:
Command : echo bla > bla.txt
stdout : bla > bla.txt
ExitValue : 0
So bla > bla.txt is written to stdout but of course there is no redirect to bla.txt.
Perhapes shell redirects are not possible in a simple exec().
So I tried to change the command = "/bin/bash -c 'echo bla > bla.txt'" to use the whole echo and redirect as a parameter to /bin/bash.
With this I get the result:
Command : /bin/bash -c 'echo bla > bla.txt'
error : bla: -c: line 0: unexpected EOF while looking for matching `''
error : bla: -c: line 1: syntax error: unexpected end of file
ExitValue : 1
Of course /bin/bash -c 'echo bla > bla.txt'works fine on Ubuntu and creates the desired file.
I found no place where I could set the single quotes to get a satisfying result, and I also tried with all kinds of escape characters to escape the spaces or the redirect (>).
It works if I use a command array like
String cmdArray[] = {"/bin/bash", "-c", "echo bla > bla.txt"};
Process process = runtime.exec(cmdArray);
, but it has to be a single string because the entire command has to be build somewhere else.
I surely know
that there are better ways to write strings to files,
that it may be a bad idea to execute commands build somewhere else,
and so on ...
I'm just curious why this does not work.

The cause is that exec uses simple StringTokenizer with any white space as a delimiter to parse the actual command. Therefore it's portable as it does work nowhere when you pass something complex :-)
The workaround you chose is correct way, portable and most of all safest asyou ddon't need to escape if the command contained for example quotes etc.

String command = "echo bla > bla.txt";
Process process = runtime.exec(command);
The > blah.txt text in your command is shell syntax to redirect standard output. It's implemented by shells like sh or bash.
Runtime.exec() doesn't use a shell to run commands. The way it launches commands is described here and here. Basically, it uses its own logic to split the command string into arguments at spaces, then directly executes the resulting command.
If you want to invoke a command which should be interpreted as a shell command, you need to explicitly invoke a shell:
String[] command = { "/bin/bash", "-c", "echo bla > bla.txt" };
Process process = runtime.exec(command);

Can't execute Shellscript successfully using getruntime.exec()

I have written a code to execute a script from java :
String wrapper_script=homedir+"/blast_distribute.sh "+" --seqs="+seqs+" --i="+formobj.getUpFile().getFileName()+" "+formobj.getSelected_program();
script_exec=Runtime.getRuntime().exec(wrapper_script);
This works perfect for me as command is executed successfully. Now I need to run this command as other user so I need to execute a command in a format like :
su username -c 'command'
SO I have edited above script_exec string as :
String wrapper_script1="su - "+username+" -c "+"'"+wrapper_script+"'";
I have printed wrapper_script1 which diplays:
su - abhijeet -c '/home/abhijeet//blast_distribute.sh --seqs=1562
--i=mPS_0.contigs.fasta'
If I run same command directly on Linux,It works exactly as I need.But When I am running through :
script_exec=Runtime.getRuntime().exec(wrapper_script1);
It does't work properly ,In my error stream I get error as
su: unrecognized option '--seqs=1562' Try `su --help' for more
information.
I have tried a lot but could't resolve the issue.What can be the reason for this issue?

You should use multiple parameters run for this:
Runtime.getRuntime().exec(new String[] {"su", "-", username, "-c",
homedir + "/blast_distribute.sh " + " --seqs=" + seqs + " --i=" + formobj.getUpFile().getFileName() + " " + formobj.getSelected_program()
});
You're getting the error, because ' is not treated here as a enclosing characters, but as a parameters for su command.
Let's look into details. When you type into console some command like su - jsmith -c 'aba --cabga', what you're doing is: "run command su with such an arguments: -, jsmith, -c, aba --caba (one argument for multiple words)".
The same thing you should do in your Java code. There's special command in Java API for running the concrete command with concrete arguments instead of parsing line as shell do: Runtime.exec(String[]): the first argument is command, the next are the arguments. That's what we do in this code block.