Przekieruj potok wyjściowy procesu potomnego w Go

Piszę program w Go, który wykonuje program podobny do serwera (także Go). Teraz chcę mieć standardowe wyjście programu potomnego w moim oknie terminala, w którym uruchomiłem program nadrzędny. Jednym ze sposobów jest użycie cmd.Output()funkcji, ale wypisuje ona standardowe wyjście dopiero po zakończeniu procesu. (To problem, ponieważ ten program podobny do serwera działa przez długi czas i chcę odczytać dane wyjściowe dziennika)

Zmienna outma wartość type io.ReadCloseri nie wiem, co mam z nią zrobić, aby wykonać swoje zadanie, i nie mogę znaleźć w sieci nic pomocnego na ten temat.

func main() {
    cmd := exec.Command("/path/to/my/child/program")
    out, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println(err)
    }
    err = cmd.Start()
    if err != nil {
        fmt.Println(err)
    }
    //fmt.Println(out)
    cmd.Wait()
} 

Wyjaśnienie do kodu: odkomentuj Printlnfunkcję, aby uzyskać kod do skompilowania, wiem, że Println(out io.ReadCloser)nie jest to znacząca funkcja.
(generuje wynik &{3 |0 <nil> 0}) Te dwa wiersze są potrzebne tylko do pobrania kodu do kompilacji.

Teraz chcę mieć standardowe wyjście programu potomnego w moim oknie terminala, w którym uruchomiłem program nadrzędny.

Nie musisz majstrować przy rurach ani gorutynach, ten jest łatwy.

func main() {
    // Replace `ls` (and its arguments) with something more interesting
    cmd := exec.Command("ls", "-l")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    cmd.Run()
}

Wierzę, że jeśli import ioi osi to wymienić:

//fmt.Println(out)

z tym:

go io.Copy(os.Stdout, out)

(zobacz dokumentację dlaio.Copy i dlaos.Stdout ), zrobi to, co chcesz. (Zastrzeżenie: nie testowane.)

Nawiasem mówiąc, prawdopodobnie będziesz chciał również przechwytywać standardowe błędy, używając tego samego podejścia, co w przypadku standardowego wyjścia, ale z cmd.StderrPipei os.Stderr.

Dla tych, którzy nie potrzebują tego w pętli, ale chcieliby, aby wyjście polecenia było echem do terminala bez cmd.Wait()blokowania innych instrukcji:

package main

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

func checkError(err error) {
    if err != nil {
        log.Fatalf("Error: %s", err)
    }
}

func main() {
    // Replace `ls` (and its arguments) with something more interesting
    cmd := exec.Command("ls", "-l")

    // Create stdout, stderr streams of type io.Reader
    stdout, err := cmd.StdoutPipe()
    checkError(err)
    stderr, err := cmd.StderrPipe()
    checkError(err)

    // Start command
    err = cmd.Start()
    checkError(err)

    // Don't let main() exit before our command has finished running
    defer cmd.Wait()  // Doesn't block

    // Non-blockingly echo command output to terminal
    go io.Copy(os.Stdout, stdout)
    go io.Copy(os.Stderr, stderr)

    // I love Go's trivial concurrency :-D
    fmt.Printf("Do other stuff here! No need to wait.\n\n")
}