Go: Empfangen os.cmd stdout und stderr in Reihenfolge

Question

Ich muss Unterbefehl von gehen und stdout und stderr getrennt verarbeiten, mit der Reihenfolge der Ausgabe, die zu stdin/stdout kommt. Ich habe mehrere verschiedene Wege ausprobiert, aber konnte nicht die richtige Reihenfolge der Ausgabe erreichen; folgender Code zeigt, dass ouput Handhabung, um absolut zufällig ist:

package main 

import (
    "fmt" 
    "log" 
    "os/exec" 
) 

var (
    result = "" 
) 

type writer struct { 
    result string 
    write func(bytes []byte) 
} 

func (writer *writer) Write(bytes []byte) (int, error) { 
    writer.result += string(bytes) // process result later 
    result += string(bytes) 
    return len(bytes), nil 
} 

func main() { 
    cmd := exec.Command("bash", "-c", "echo TEST1; echo TEST2 1>&2; echo TEST3") 

    stderr := &writer{} 
    cmd.Stderr = stderr 

    stdout := &writer{} 
    cmd.Stdout = stdout 

    err := cmd.Start() 
    if err != nil { 
     log.Fatal(err) 
    } 

    err = cmd.Wait() 
    if err != nil { 
     log.Fatal(err) 
    } 

    fmt.Println(result) 
} 

Mit mehreren Läufen Code ausgegeben folgenden:

$ go run main.go 
TEST1 
TEST3 
TEST2 

Ich erwarte, dass folgendes Ergebnis in allen Fällen:

$ go run main.go 
TEST1 
TEST2 
TEST3 

ich kann Rufen Sie nicht cmd.CombinedOutput auf, da ich stdout/stderr separat und in Echtzeit verarbeiten muss.

Answer 1

Es gibt keine "Reihenfolge" mit dem Befehl, den Sie ausführen. Sie sind parallele Pipes, und als solche sind sie effektiv auf die gleiche Art und Weise wie zwei Goroutines gleichzeitig. Sie können sie sicher in der Reihenfolge speichern, in der Sie sie empfangen und sie mit ihrer Quelle versehen, indem Sie Kanäle oder einen Mutex verwenden. Um die Ausgabe mit Ihrem synthetischen Beispiel nicht zufällig zu machen, müssen Sie ein bisschen Pause hinzufügen. Ich habe diese Methode erfolgreich mit echten Befehlen verwendet, aber:

package main 

import (
    "fmt" 
    "log" 
    "os/exec" 
    "sync" 
) 

var (
    result = "" 
) 

type write struct { 
    source string 
    data string 
} 

type writer struct { 
    source string 

    mu  *sync.Mutex 
    writes *[]write 
} 

func (w *writer) Write(bytes []byte) (int, error) { 
    w.mu.Lock() 
    defer w.mu.Unlock() 
    *w.writes = append(*w.writes, write{ 
      source: w.source, 
      data: string(bytes), 
    }) 
    return len(bytes), nil 
} 

func main() { 
    cmd := exec.Command("bash", "-c", "echo TEST1; sleep .1; echo TEST2 1>&2; sleep .1; echo TEST3") 

    var mu sync.Mutex 
    var writes []write 

    cmd.Stderr = &writer{ 
      source: "STDERR", 
      mu:  &mu, 
      writes: &writes, 
    } 
    cmd.Stdout = &writer{ 
      source: "STDOUT", 
      mu:  &mu, 
      writes: &writes, 
    } 

    err := cmd.Start() 
    if err != nil { 
      log.Fatal(err) 
    } 

    err = cmd.Wait() 
    if err != nil { 
      log.Fatal(err) 
    } 

    fmt.Printf("%q\n", writes) 
} 

[{"STDOUT" "TEST1\n"} {"STDERR" "TEST2\n"} {"STDOUT" "TEST3\n"}]