Pipe to exec'ed process

Question

My Go application outputs some amounts of text data and I need to pipe it to some external command (e.g. less). I haven't find any way to pipe this data to syscall.Exec'ed process.

As a workaround I write that text data to a temporary file and then use that file as an argument to less:

package main

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

func main() {
    content := []byte("temporary file's content")
    tmpfile, err := ioutil.TempFile("", "example")
    if err != nil {
        log.Fatal(err)
    }

    defer os.Remove(tmpfile.Name()) // Never going to happen!

    if _, err := tmpfile.Write(content); err != nil {
        log.Fatal(err)
    }
    if err := tmpfile.Close(); err != nil {
        log.Fatal(err)
    }

    binary, err := exec.LookPath("less")
    if err != nil {
        log.Fatal(err)
    }

    args := []string{"less", tmpfile.Name()}

    if err := syscall.Exec(binary, args, os.Environ()); err != nil {
        log.Fatal(err)
    }
}

It works but leaves a temporary file on a file system, because syscall.Exec replaces the current Go process with another (less) one and deferred os.Remove won't run. Such behaviour is not desirable.

Is there any way to pipe some data to an external process without leaving any artefacts?

Answer 1

You should be using os/exec to build an exec.Cmd to execute, then you could supply any io.Reader you want as the stdin for the command.

From the example in the documentation:

cmd := exec.Command("tr", "a-z", "A-Z")
cmd.Stdin = strings.NewReader("some input")
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("in all caps: %q\n", out.String())

If you want to write directly to the command's stdin, then you call cmd.StdInPipe to get an io.WriteCloser you can write to.

If you really need to exec the process in place of your current one, you can simply remove the file before exec'ing, and provide that file descriptor as stdin for the program.

content := []byte("temporary file's content")
tmpfile, err := ioutil.TempFile("", "example")
if err != nil {
    log.Fatal(err)
}
os.Remove(tmpfile.Name())

if _, err := tmpfile.Write(content); err != nil {
    log.Fatal(err)
}

tmpfile.Seek(0, 0)

err = syscall.Dup2(int(tmpfile.Fd()), syscall.Stdin)
if err != nil {
    log.Fatal(err)
}

binary, err := exec.LookPath("less")
if err != nil {
    log.Fatal(err)
}

args := []string{"less"}

if err := syscall.Exec(binary, args, os.Environ()); err != nil {
    log.Fatal(err)
}