External Processes

def proc = 'echo hello from a child'.execute()
println proc.class.name
print proc.text                        // reads stdout until it closes
println proc.waitFor()                 // exit value

def args = ['echo', 'two words', 'x'].execute()   // a List keeps each element as one argument
println args.text.trim()

def failing = 'ls /definitely/not/here'.execute()
failing.waitFor()
println failing.exitValue()
println failing.err.text.trim().contains('No such file')
println 'true'.execute().waitFor()
println 'false'.execute().waitFor()
try { 'no-such-command-xyz'.execute() } catch (IOException e) { println e.class.simpleName }

java.lang.ProcessImpl
hello from a child
0
two words x
1
true
0
1
IOException

def one = 'printf "b\\na\\n"'.execute()          // a String is split on spaces: the quotes reach printf
println one.text.readLines()
def two = ['printf', 'b\na\n'].execute()          // a List keeps arguments intact
println two.text.readLines()
println 'echo $HOME'.execute().text.trim()        // no shell, so nothing is expanded
println 'echo *'.execute().text.trim()
println(['sh', '-c', 'echo "$((6 * 7))"'].execute().text.trim())   // ask a shell explicitly
def dir = new File('work/my beds')
dir.mkdirs()
new File(dir, 'a.txt').text = 'x'
def bad = "ls ${dir.path}".execute()             // the space splits the path in two arguments
bad.waitFor()
println bad.exitValue()
println(['ls', dir.path].execute().text.trim())

["b, a, "]
[b, a]
$HOME
*
42
1
a.txt

def p = ['sh', '-c', 'echo out; echo err 1>&2; exit 3'].execute()
def out = new StringBuilder(), err = new StringBuilder()
p.consumeProcessOutput(out, err)       // drains both pipes in background threads
p.waitFor()
println "exit=${p.exitValue()} out=${out.toString().trim()} err=${err.toString().trim()}"

def q = ['sh', '-c', 'echo a; echo b 1>&2'].execute()
def o2 = new StringBuilder(), e2 = new StringBuilder()
q.waitForProcessOutput(o2, e2)         // consume both streams and wait for exit
println([o2.toString().trim(), e2.toString().trim()])

def lines = []
['printf', 'x\ny\n'].execute().in.eachLine { lines << it }   // 'in' is the child's stdout
println lines

exit=3 out=out err=err
[a, b]
[x, y]

def sorted = ['printf', 'b\na\nc\n'].execute() | ['sort'].execute()
println sorted.text.readLines()

def procs = [['printf', 'x\ny\nx\n'], ['sort'], ['uniq', '-c']].pipeline()
println procs.size()
println procs.last().text.readLines()*.trim()

def cat = ['cat'].execute()
cat.withWriter { it << 'via the writer\n' }       // closing the writer ends stdin
println cat.text.trim()
def srt = ['sort'].execute()
srt << 'pear\napple\n'
srt.out.close()
println srt.text.readLines()

[a, b, c]
3
[2 x, 1 y]
via the writer
[apple, pear]

import java.util.concurrent.TimeUnit
def slow = ['sleep', '5'].execute()
slow.waitForOrKill(300)               // destroys the process after 300 ms
println slow.waitFor()                // 143 = 128 + SIGTERM
def p = ['sleep', '5'].execute()
println p.waitFor(300, TimeUnit.MILLISECONDS)   // the JDK method: false means still running
p.destroy()
def r = ['sleep', '5'].execute().waitForResult(300, TimeUnit.MILLISECONDS)
println r

def f = ['echo', 'async'].execute().onExit()      // CompletableFuture<Process>
println f.get().exitValue()
def pb = ['sh', '-c', 'echo $0 $1', 'a', 'b'].toProcessBuilder()
println pb.class.simpleName
pb.redirectErrorStream(true)
println pb.start().text.trim()

143
false
ProcessResult(exitCode=137, out="", err="")
0
ProcessBuilder
a b

def work = new File('work')
println(['pwd'].execute(dir: work).text.trim().endsWith('/work'))
println(['sh', '-c', 'echo $GREENHOUSE_BED'].execute(env: [GREENHOUSE_BED: 'bed7']).text.trim())
println(['sh', '-c', 'echo "${HOME:+HOME kept} $GREENHOUSE_BED"'].execute(env: [GREENHOUSE_BED: 'bed7']).text.trim())
println(['sh', '-c', 'echo "${HOME:+HOME kept} $GREENHOUSE_BED"'].execute(['GREENHOUSE_BED=bed7'], null).text.trim())
def merged = ['sh', '-c', 'echo out; echo err 1>&2'].execute(redirectErrorStream: true)
println merged.text.readLines().sort()
def out = new File('work/out.txt')
out.delete()
['echo', 'to a file'].execute(outputFile: out).waitFor()
['echo', 'more'].execute(appendOutput: out).waitFor()
println out.readLines()
def ins = new File('work/in.txt'); ins.text = 'c\nb\na\n'
println(['sort'].execute(inputFile: ins).text.readLines())
def res = ['sh', '-c', 'echo out; echo err 1>&2; exit 2'].execute().waitForResult()
println res
println([res.out.trim(), res.err.trim(), res.exitCode, res.ok])
println(['true'].execute().waitForResult().ok)
def errFile = new File('work/err.txt'); errFile.delete()
['sh', '-c', 'echo oops 1>&2'].execute(errorFile: errFile).waitFor()
println errFile.readLines()

true
bed7
HOME kept bed7
bed7
[err, out]
[to a file, more]
[a, b, c]
ProcessResult(exitCode=2, out="out", err="err")
[out, err, 2, false]
true
[oops]