Redirigir la tubería de salida estándar del proceso hijo en Go

Estoy escribiendo un programa en Go que ejecuta un programa similar a un servidor (también Go). Ahora quiero tener la salida estándar del programa secundario en la ventana de mi terminal donde inicié el programa principal. Una forma de hacer esto es con la cmd.Output()función, pero esta imprime la salida estándar solo después de que el proceso haya finalizado. (Eso es un problema porque este programa similar a un servidor se ejecuta durante mucho tiempo y quiero leer la salida del registro)

La variable outes de type io.ReadClosery no sé qué debo hacer con ella para lograr mi tarea, y no puedo encontrar nada útil en la web sobre este tema.

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

Explicación del código: descomente la Printlnfunción para que el código se compile, sé que Println(out io.ReadCloser)no es una función significativa.
(produce la salida &{3 |0 <nil> 0}) Estas dos líneas solo son necesarias para que el código se compile.

Ahora quiero tener la salida estándar del programa secundario en la ventana de mi terminal donde inicié el programa principal.

No es necesario meterse con tuberías o goroutines, este es 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()
}

Creo que si importa ioy osy sustituir este:

//fmt.Println(out)

con este:

go io.Copy(os.Stdout, out)

(ver documentación paraio.Copy y paraos.Stdout ), hará lo que quieras. (Descargo de responsabilidad: no probado).

Por cierto, probablemente también querrá capturar el error estándar, utilizando el mismo enfoque que para la salida estándar, pero con cmd.StderrPipey os.Stderr.

Para aquellos que no necesitan esto en un bucle, pero les gustaría que la salida del comando se hiciera eco en la terminal sin tener que cmd.Wait()bloquear otras declaraciones:

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