Rediriger le tube stdout du processus enfant dans Go

J'écris un programme en Go qui exécute un programme de type serveur (également Go). Maintenant, je veux avoir le stdout du programme enfant dans ma fenêtre de terminal où j'ai démarré le programme parent. Une façon de le faire est d'utiliser la cmd.Output()fonction, mais cela n'imprime le stdout qu'une fois le processus terminé. (C'est un problème car ce programme de type serveur fonctionne pendant longtemps et je souhaite lire la sortie du journal)

La variable outest de type io.ReadCloseret je ne sais pas ce que je dois en faire pour accomplir ma tâche, et je ne trouve rien d'utile sur le Web à ce sujet.

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

Explication au code: décommentez la Printlnfonction pour obtenir le code à compiler, je sais que ce Println(out io.ReadCloser)n'est pas une fonction significative.
(il produit la sortie &{3 |0 <nil> 0}) Ces deux lignes sont juste nécessaires pour obtenir le code à compiler.

Maintenant, je veux avoir le stdout du programme enfant dans ma fenêtre de terminal où j'ai démarré le programme parent.

Pas besoin de jouer avec des pipes ou des goroutines, celui-ci est 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()
}

Je crois que si vous importez ioet oset remplacer ceci:

//fmt.Println(out)

avec ça:

go io.Copy(os.Stdout, out)

(voir documentation pourio.Copy et pouros.Stdout ), il fera ce que vous voulez. (Avertissement: non testé.)

Au fait, vous voudrez probablement aussi capturer l'erreur standard, en utilisant la même approche que pour la sortie standard, mais avec cmd.StderrPipeet os.Stderr.

Pour ceux qui n'en ont pas besoin dans une boucle, mais qui aimeraient que la sortie de la commande fasse écho dans le terminal sans avoir à cmd.Wait()bloquer d'autres instructions:

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