Groovy ejecutando comandos de shell

Question

Groovy agrega el método execute al String para hacer que los shells de ejecución sean bastante fáciles;

println "ls".execute().text 

pero si ocurre un error, no hay salida resultante. ¿Existe alguna manera fácil de obtener el error estándar y el estándar? (además de crear un montón de código para; crear dos subprocesos para leer ambos flujos de entrada, luego usar una secuencia primaria para esperar a que se completen y luego convertir las cadenas de nuevo a texto?)

Sería bueno tener algo me gusta;

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

Answer 1

Ok, resuelto mí 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

Answer 2

"ls".execute() devuelve un objeto Process razón por la cual "ls".execute().text obras. Debería poder leer la secuencia de error para determinar si hubo algún error.

Hay un método adicional en Process que le permite pasar un StringBuffer para recuperar el texto: consumeProcessErrorStream(StringBuffer error).

Ejemplo:

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

println proc.text 
println b.toString() 

Answer 3

// 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() 
} 

Answer 4

Para añadir una información más importante respuestas proporcionadas anteriormente -

Para un proceso

def proc = command.execute(); 

Siempre trate de usar

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

en lugar de

def output = proc.in.text; 

para capturar las salidas después de ejecutar comandos en el maravilloso ya que esta última es una llamada de bloqueo (SO question for reason).

Answer 5

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] 

Answer 6

Me parece más idiomática:

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 se menciona otro post, se trata de llamadas de bloqueo, pero ya que queremos trabajar con la salida, esto puede ser necesario.

Answer 7

command = "ls *" 

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

pero si el comando falla el proceso terminará