go - segundo - que es el aluminio primario

Redirigir la tubería stdout del proceso secundario en Ir

Question

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

La variable de out es del type io.ReadCloser y no sé qué debo hacer 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 función Println para obtener el código para compilar, 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 obtener el código para compilar.

Answer 1

Ahora quiero tener el stdout del programa secundario en la ventana de mi terminal donde comencé el programa principal.

No hay necesidad de meterse con tuberías o gorutines, 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()
}

Answer 2

Creo que si importas io y os y reemplazas esto:

//fmt.Println(out)

con este:

go io.Copy(os.Stdout, out)

(Consulte la documentación para io.Copy y para os.Stdout ), hará lo que usted desee. (Descargo de responsabilidad: no probado)

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

Answer 3

Para aquellos que no necesitan esto en un bucle, pero quisieran que la salida del comando hiciera eco en el terminal sin tener cmd.Wait() bloqueando 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")
}