Reindirizza la pipe stdout del processo figlio in Go

Sto scrivendo un programma in Go che esegue un programma simile a un server (anche Go). Ora voglio avere lo stdout del programma figlio nella mia finestra del terminale dove ho avviato il programma genitore. Un modo per farlo è con la cmd.Output()funzione, ma questa stampa lo stdout solo dopo che il processo è terminato. (Questo è un problema perché questo programma simile a un server viene eseguito per molto tempo e voglio leggere l'output del registro)

La variabile outè di type io.ReadClosere non so cosa dovrei farne per svolgere il mio compito, e non riesco a trovare nulla di utile sul web su questo argomento.

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

Spiegazione del codice: rimuovere il commento dalla Printlnfunzione per compilare il codice, so che Println(out io.ReadCloser)non è una funzione significativa.
(produce l'output &{3 |0 <nil> 0}) Queste due righe sono necessarie solo per ottenere il codice da compilare.

Ora voglio avere lo stdout del programma figlio nella mia finestra del terminale dove ho avviato il programma genitore.

Non c'è bisogno di scherzare con pipe o goroutine, questo è facile.

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

Credo che se si importa ioe ose sostituire questo:

//fmt.Println(out)

con questo:

go io.Copy(os.Stdout, out)

(vedi la documentazione perio.Copy e peros.Stdout ), farà quello che vuoi. (Disclaimer: non testato.)

A proposito, probabilmente vorrai catturare anche l'errore standard, usando lo stesso approccio dell'output standard, ma con cmd.StderrPipee os.Stderr.

Per coloro che non ne hanno bisogno in un ciclo, ma vorrebbero che l'output del comando echeggi nel terminale senza dover cmd.Wait()bloccare altre istruzioni:

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