Groovy, das Shell-Befehle ausführt

Groovy fügt die executeMethode hinzu String, um das Ausführen von Shells ziemlich einfach zu machen.

println "ls".execute().text

Wenn jedoch ein Fehler auftritt, wird keine Ausgabe ausgegeben. Gibt es eine einfache Möglichkeit, sowohl den Standardfehler als auch den Standard zu ermitteln? (außer eine Menge Code zu erstellen; zwei Threads erstellen, um beide Eingabestreams zu lesen, und dann einen übergeordneten Stream verwenden, um darauf zu warten, dass sie abgeschlossen sind, und dann die Zeichenfolgen wieder in Text konvertieren?)

Es wäre schön, so etwas zu haben;

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

Ok, habe es selbst gelöst;

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

zeigt an:

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

"ls".execute()Gibt ein ProcessObjekt zurück, weshalb es "ls".execute().textfunktioniert. Sie sollten in der Lage sein, nur den Fehlerstrom zu lesen, um festzustellen, ob Fehler aufgetreten sind.

Es gibt eine zusätzliche Methode Process, mit der Sie eine übergeben können StringBuffer, um den Text abzurufen : consumeProcessErrorStream(StringBuffer error).

Beispiel:

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

Ich finde das idiomatischer:

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"

Wie in einem anderen Beitrag erwähnt, blockieren diese Anrufe, aber da wir mit der Ausgabe arbeiten möchten, kann dies erforderlich sein.

Um eine weitere wichtige Information zu den oben angegebenen Antworten hinzuzufügen -

Für einen Prozess

def proc = command.execute();

versuche immer zu benutzen

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

eher, als

def output = proc.in.text;

Das Erfassen der Ausgänge nach dem Ausführen von Befehlen in Groovy, da letzterer ein blockierender Aufruf ist ( SO-Frage aus gutem Grund ).

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)

Wenn der Befehl fehlschlägt, wird der Prozess beendet