Scala Process - Capture Standard Out and Exit Code

Question

Pracuję z biblioteką Scala scala.sys.process.

Wiem, że mogę przechwytywać kod wyjścia z ! i wyjście z !!, ale co jeśli chcę przechwycić oba?

Widziałem tę odpowiedź https://stackoverflow.com/a/6013932/416338, która wygląda obiecująco, ale zastanawiam się, czy istnieje jedna linijka i czegoś brakuje.

Answer 1

Można użyć ProcessIO. Potrzebowałem czegoś takiego w Specs2 Test, gdzie musiałem sprawdzić wartość wyjściową, a także wyjścia procesu w zależności od wejścia na stdin (in i out są typu String):

"the operation" should { 
    f"return '$out' on input '$in'" in { 
    var res = "" 
    val io = new ProcessIO(
     stdin => { stdin.write(in.getBytes) 
        stdin.close() }, 
     stdout => { res = convertStreamToString(stdout) 
        stdout.close() }, 
     stderr => { stderr.close() }) 
    val proc = f"$operation $file".run(io) 
    proc.exitValue() must be_==(0) 
    res must be_==(out) 
    } 
} 

I Pomyślałem, że może ci pomóc. W tym przykładzie ignoruję to, co kiedykolwiek pochodzi z stderr.

Answer 2

Odpowiedź udzielona przez "Alex Cruise" w twoim linku jest dość zwięzła, co wyklucza gorsze wyniki.

Można przedłużyć sys.process.ProcessLogger zarządzać

var out = List[String]() 
var err = List[String]() 

wewnętrznie, z pobierające dla out.reverse i err.reverse wyników.

Answer 3

Mam następujący sposób narzędzie służące do wykonywania poleceń:

import sys.process._ 
def runCommand(cmd: Seq[String]): (Int, String, String) = { 
    val stdoutStream = new ByteArrayOutputStream 
    val stderrStream = new ByteArrayOutputStream 
    val stdoutWriter = new PrintWriter(stdoutStream) 
    val stderrWriter = new PrintWriter(stderrStream) 
    val exitValue = cmd.!(ProcessLogger(stdoutWriter.println, stderrWriter.println)) 
    stdoutWriter.close() 
    stderrWriter.close() 
    (exitValue, stdoutStream.toString, stderrStream.toString) 
} 

Jak widać, to przechwytuje stdout, stderr i kod wynikowy.

Answer 4

Jednoskładkowe użycie BasicIO lub ProcessLogger jest atrakcyjne.

scala> val sb = new StringBuffer 
sb: StringBuffer = 

scala> ("/bin/ls /tmp" run BasicIO(false, sb, None)).exitValue 
res0: Int = 0 

scala> sb 
res1: StringBuffer = ... 

lub

scala> import collection.mutable.ListBuffer 
import collection.mutable.ListBuffer 

scala> val b = ListBuffer[String]() 
b: scala.collection.mutable.ListBuffer[String] = ListBuffer() 

scala> ("/bin/ls /tmp" run ProcessLogger(b append _)).exitValue 
res4: Int = 0 

scala> b mkString "\n" 
res5: String = ... 

W zależności od tego, co masz na myśli przez porwanie, może jesteś zainteresowany wyjścia, chyba że kod wyjścia jest niezerowy. W takim przypadku zajmij się wyjątkiem.

scala> val re = "Nonzero exit value: (\\d+)".r.unanchored 
re: scala.util.matching.UnanchoredRegex = Nonzero exit value: (\d+) 

scala> Try ("./bomb.sh" !!) match { 
    | case Failure(f) => f.getMessage match { 
    | case re(x) => println(s"Bad exit $x") 
    | } 
    | case Success(s) => println(s) 
    | } 
warning: there were 1 feature warning(s); re-run with -feature for details 
Bad exit 3 

Answer 5

Można określić strumień wyjściowy, który łapie tekst:

import sys.process._ 
val os = new java.io.ByteArrayOutputStream 
val code = ("volname" #> os).! 
os.close() 
val opt = if (code == 0) Some(os.toString("UTF-8")) else None