Redirecionar o pipe stdout do processo filho no Go

Estou escrevendo um programa em Go que executa um programa semelhante a um servidor (também Go). Agora, quero ter o stdout do programa filho na janela do terminal onde iniciei o programa pai. Uma maneira de fazer isso é com a cmd.Output()função, mas ela imprime o stdout somente depois que o processo é encerrado. (Isso é um problema porque este programa semelhante a um servidor é executado por um longo tempo e eu quero ler a saída do log)

A variável outé de type io.ReadClosere não sei o que devo fazer com ela para cumprir minha tarefa e não consigo encontrar nada de útil na web sobre esse assunto.

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

Explicação para o código: descomente a Printlnfunção para obter o código para compilar, eu sei que Println(out io.ReadCloser)não é uma função significativa.
(produz a saída &{3 |0 <nil> 0}) Essas duas linhas são necessárias apenas para obter o código para compilar.

Agora, quero ter o stdout do programa filho na janela do terminal onde iniciei o programa pai.

Não há necessidade de mexer com canos ou goroutines, este é fácil.

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

Eu acredito que se você importar ioe ose substituir este:

//fmt.Println(out)

com isso:

go io.Copy(os.Stdout, out)

(consulte a documentação paraio.Copy e paraos.Stdout ), ele fará o que você quiser. (Isenção de responsabilidade: não testado.)

A propósito, provavelmente você também desejará capturar o erro padrão, usando a mesma abordagem que para a saída padrão, mas com cmd.StderrPipee os.Stderr.

Para aqueles que não precisam disso em um loop, mas gostariam que a saída do comando ecoasse no terminal sem cmd.Wait()bloquear outras instruções:

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