Groovy ejecutando comandos de shell

Groovy agrega el executemétodo para Stringhacer que la ejecución de shells sea bastante fácil;

println "ls".execute().text

pero si ocurre un error, entonces no hay salida resultante. ¿Hay una manera fácil de obtener tanto el error estándar como el estándar? (¿aparte de crear un montón de código para crear dos hilos para leer ambos flujos de entrada, luego usar un flujo principal para esperar a que se completen y luego convertir las cadenas de nuevo en texto?)

Sería bueno tener algo así;

 def x = shellDo("ls /tmp/NoFile")
 println "out: ${x.out} err:${x.err}"

Ok, lo resolví yo mismo;

def sout = new StringBuilder(), serr = new StringBuilder()
def proc = 'ls /badDir'.execute()
proc.consumeProcessOutput(sout, serr)
proc.waitForOrKill(1000)
println "out> $sout err> $serr"

muestra:

out> err> ls: cannot access /badDir: No such file or directory

"ls".execute()devuelve un Processobjeto por lo que "ls".execute().textfunciona. Debería poder simplemente leer la secuencia de errores para determinar si hubo algún error.

Existe un método adicional en Processque permiten pasar de una StringBuffera recuperar el texto: consumeProcessErrorStream(StringBuffer error).

Ejemplo:

def proc = "ls".execute()
def b = new StringBuffer()
proc.consumeProcessErrorStream(b)

println proc.text
println b.toString()

// a wrapper closure around executing a string                                  
// can take either a string or a list of strings (for arguments with spaces)    
// prints all output, complains and halts on error                              
def runCommand = { strList ->
  assert ( strList instanceof String ||
           ( strList instanceof List && strList.each{ it instanceof String } ) \
)
  def proc = strList.execute()
  proc.in.eachLine { line -> println line }
  proc.out.close()
  proc.waitFor()

  print "[INFO] ( "
  if(strList instanceof List) {
    strList.each { print "${it} " }
  } else {
    print strList
  }
  println " )"

  if (proc.exitValue()) {
    println "gave the following error: "
    println "[ERROR] ${proc.getErrorStream()}"
  }
  assert !proc.exitValue()
}

Esto me parece más idiomático:

def proc = "ls foo.txt doesnotexist.txt".execute()
assert proc.in.text == "foo.txt\n"
assert proc.err.text == "ls: doesnotexist.txt: No such file or directory\n"

Como menciona otra publicación, estas son llamadas de bloqueo, pero dado que queremos trabajar con la salida, esto puede ser necesario.

Para agregar una información más importante a las respuestas proporcionadas anteriormente:

Para un proceso

def proc = command.execute();

siempre trata de usar

def outputStream = new StringBuffer();
proc.waitForProcessOutput(outputStream, System.err)
//proc.waitForProcessOutput(System.out, System.err)

más bien que

def output = proc.in.text;

para capturar las salidas después de ejecutar comandos en groovy ya que esta última es una llamada de bloqueo ( pregunta SO por razón ).

def exec = { encoding, execPath, execStr, execCommands ->

def outputCatcher = new ByteArrayOutputStream()
def errorCatcher = new ByteArrayOutputStream()

def proc = execStr.execute(null, new File(execPath))
def inputCatcher = proc.outputStream

execCommands.each { cm ->
    inputCatcher.write(cm.getBytes(encoding))
    inputCatcher.flush()
}

proc.consumeProcessOutput(outputCatcher, errorCatcher)
proc.waitFor()

return [new String(outputCatcher.toByteArray(), encoding), new String(errorCatcher.toByteArray(), encoding)]

}

def out = exec("cp866", "C:\\Test", "cmd", ["cd..\n", "dir\n", "exit\n"])

println "OUT:\n" + out[0]
println "ERR:\n" + out[1]

command = "ls *"

def execute_state=sh(returnStdout: true, script: command)

pero si el comando falla, el proceso terminará