Wie leite ich mehrere Befehle in Go weiter?

Wie kann ich in Go mehrere externe Befehle zusammenleiten? Ich habe diesen Code ausprobiert, erhalte jedoch eine Fehlermeldung exit status 1.

package main

import (
    "io"
    "log"
    "os"
    "os/exec"
)

func main() {
    c1 := exec.Command("ls")
    stdout1, err := c1.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }

    if err = c1.Start(); err != nil {
        log.Fatal(err)
    }
    if err = c1.Wait(); err != nil {
        log.Fatal(err)
    }

    c2 := exec.Command("wc", "-l")
    c2.Stdin = stdout1

    stdout2, err := c2.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }

    if err = c2.Start(); err != nil {
        log.Fatal(err)
    }
    if err = c2.Wait(); err != nil {
        log.Fatal(err)
    }

    io.Copy(os.Stdout, stdout2)
}

StdoutPipe gibt eine Pipe zurück, die beim Start des Befehls mit der Standardausgabe des Befehls verbunden wird. Die Pipe wird automatisch geschlossen, nachdem Wait den Befehl beendet hat.

(von http://golang.org/pkg/os/exec/#Cmd.StdinPipe )

Die Tatsache, dass Sie dies tun, c1.Waitschließt das stdoutPipe.

Ich habe ein funktionierendes Beispiel gemacht (nur eine Demo, Fehlerbehebung hinzufügen!):

package main

import (
    "bytes"
    "io"
    "os"
    "os/exec"
)

func main() {
    c1 := exec.Command("ls")
    c2 := exec.Command("wc", "-l")

    r, w := io.Pipe() 
    c1.Stdout = w
    c2.Stdin = r

    var b2 bytes.Buffer
    c2.Stdout = &b2

    c1.Start()
    c2.Start()
    c1.Wait()
    w.Close()
    c2.Wait()
    io.Copy(os.Stdout, &b2)
}

Für einfache Szenarien können Sie diesen Ansatz verwenden:

bash -c "echo 'your command goes here'"

Diese Funktion ruft beispielsweise den Namen des CPU-Modells mithilfe von Piped-Befehlen ab:

func getCPUmodel() string {
        cmd := "cat /proc/cpuinfo | egrep '^model name' | uniq | awk '{print substr($0, index($0,$4))}'"
        out, err := exec.Command("bash","-c",cmd).Output()
        if err != nil {
                return fmt.Sprintf("Failed to execute command: %s", cmd)
        }
        return string(out)
}

package main

import (
    "os"
    "os/exec"
)

func main() {
    c1 := exec.Command("ls")
    c2 := exec.Command("wc", "-l")
    c2.Stdin, _ = c1.StdoutPipe()
    c2.Stdout = os.Stdout
    _ = c2.Start()
    _ = c1.Run()
    _ = c2.Wait()
}

Wie die erste Antwort, aber mit dem ersten Befehl gestartet und in einer Goroutine gewartet. Das macht die Pfeife glücklich.

package main

import (
    "io"
    "os"
    "os/exec"
)

func main() {
    c1 := exec.Command("ls")
    c2 := exec.Command("wc", "-l")

    pr, pw := io.Pipe()
    c1.Stdout = pw
    c2.Stdin = pr
    c2.Stdout = os.Stdout

    c1.Start()
    c2.Start()

    go func() {
        defer pw.Close()

        c1.Wait()
    }()
    c2.Wait()
}

Dies ist ein voll funktionsfähiges Beispiel. Die ExecuteFunktion nimmt eine beliebige Anzahl von exec.CmdInstanzen (unter Verwendung einer variadischen Funktion ) und durchläuft sie dann korrekt, wobei die Ausgabe von stdout korrekt an die stdin des nächsten Befehls angehängt wird . Dies muss erfolgen, bevor eine Funktion aufgerufen wird.

Die Aufruffunktion ruft dann die Befehle in einer Schleife auf, verwendet Verzögerungen, um rekursiv aufzurufen, und stellt das ordnungsgemäße Schließen von Pipes sicher

package main

import (
    "bytes"
    "io"
    "log"
    "os"
    "os/exec"
)

func Execute(output_buffer *bytes.Buffer, stack ...*exec.Cmd) (err error) {
    var error_buffer bytes.Buffer
    pipe_stack := make([]*io.PipeWriter, len(stack)-1)
    i := 0
    for ; i < len(stack)-1; i++ {
        stdin_pipe, stdout_pipe := io.Pipe()
        stack[i].Stdout = stdout_pipe
        stack[i].Stderr = &error_buffer
        stack[i+1].Stdin = stdin_pipe
        pipe_stack[i] = stdout_pipe
    }
    stack[i].Stdout = output_buffer
    stack[i].Stderr = &error_buffer

    if err := call(stack, pipe_stack); err != nil {
        log.Fatalln(string(error_buffer.Bytes()), err)
    }
    return err
}

func call(stack []*exec.Cmd, pipes []*io.PipeWriter) (err error) {
    if stack[0].Process == nil {
        if err = stack[0].Start(); err != nil {
            return err
        }
    }
    if len(stack) > 1 {
        if err = stack[1].Start(); err != nil {
             return err
        }
        defer func() {
            if err == nil {
                pipes[0].Close()
                err = call(stack[1:], pipes[1:])
            }
        }()
    }
    return stack[0].Wait()
}

func main() {
    var b bytes.Buffer
    if err := Execute(&b,
        exec.Command("ls", "/Users/tyndyll/Downloads"),
        exec.Command("grep", "as"),
        exec.Command("sort", "-r"),
    ); err != nil {
        log.Fatalln(err)
    }
    io.Copy(os.Stdout, &b)
}

Verfügbar in diesem Kern

https://gist.github.com/tyndyll/89fbb2c2273f83a074dc

Ein guter Punkt zu wissen ist, dass Shell-Variablen wie ~ nicht interpoliert werden

package main

import (
    ...
    pipe "github.com/b4b4r07/go-pipe"
)

func main() {
    var b bytes.Buffer
    pipe.Command(&b,
        exec.Command("ls", "/Users/b4b4r07/Downloads"),
        exec.Command("grep", "Vim"),
    )

    io.Copy(os.Stdout, &b)
}

Ich habe einen guten Tag damit verbracht, die Antwort von Denys Séguret zu verwenden, um einen Wrapper für mehrere zu entwickeln, exec.Commandbevor ich auf dieses nette Paket von b4b4r07 gestoßen bin .