Exec a shell command in Go

Question

I'm looking to execute a shell command in Go and get the resulting output as a string in my program. I saw the Rosetta Code version:

package main
import "fmt"
import "exec"

func main() {
  cmd, err := exec.Run("/bin/ls", []string{"/bin/ls"}, []string{}, "", exec.DevNull, exec.PassThrough, exec.PassThrough)
  if (err != nil) {
    fmt.Println(err)
    return
  }
  cmd.Close()

But this doesn't capture the actual standard out or err in a way that I can programatically access - those still print out to the regular stdout / stderr. I saw that using Pipe as the out or err could help elsewhere, but no example of how to do so. Any ideas?

This might be useful in some cases: github.com/mbrostami/gcron — M Rostami
– M Rostami, Commented Apr 30, 2020 at 15:01

starball · Accepted Answer · 2022-12-23 06:20:47Z

271

The package "exec" was changed a little bit. The following code worked for me.

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    app := "echo"

    arg0 := "-e"
    arg1 := "Hello world"
    arg2 := "\n\tfrom"
    arg3 := "golang"

    cmd := exec.Command(app, arg0, arg1, arg2, arg3)
    stdout, err := cmd.Output()

    if err != nil {
        fmt.Println(err.Error())
        return
    }

    // Print the output
    fmt.Println(string(stdout))
}

edited Dec 23, 2022 at 6:20

starball♦

59.6k53 gold badges314 silver badges1k bronze badges

answered Oct 16, 2011 at 20:01

Lourenco

3,0512 gold badges17 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

AlvaroSantisteban Over a year ago

Now the import has to be like "os/exec" and I got an error with the err.String() but apart from that, it works. Thanks.

Lourenco Over a year ago

@AlvaroSantisteban, thank you. I just upgrade the post as well as point links to the package and an example of use of exec.Command.

cdunn2001 Over a year ago

Is there a simple way to separate stderr from stdout. I see CombinedOutput(), and I see more complicated ways, but what I want is simply out, errout, errcode = cmd.Output3().

Lourenco Over a year ago

@cdunn2001, (1) #easy you can set the exec.Cmd.Stderr before call cmd.Output() by yourself or (2) #hard you add your function to golang ($GOROOT/src/pkg/os/exec/exec.go), recompile (cd $GOROOT/src && ./make.bash), test it.

Parm Over a year ago

This doesn't work for wildcards i.e. *. See the answer here to see how to handle wildcards.

|

typetetris · Accepted Answer · 2022-12-06 09:37:15Z

97

None of the provided answers allow to separate stdout and stderr so I try another answer.

First you get all the info you need, if you look at the documentation of the exec.Cmd type in the os/exec package. Look here: https://golang.org/pkg/os/exec/#Cmd

Especially the members Stdin and Stdout,Stderr where any io.Reader can be used to feed stdin of your newly created process and any io.Writer can be used to consume stdout and stderr of your command.

The function Shellout in the following programm will run your command and hand you its output and error output separatly as strings.

As the parameter value is executed as a shell command, sanitize all external inputs used in the construction of the parameter value.

Probably don't use it in this form in production.

package main

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

const ShellToUse = "bash"

func Shellout(command string) (string, string, error) {
    var stdout bytes.Buffer
    var stderr bytes.Buffer
    cmd := exec.Command(ShellToUse, "-c", command)
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    err := cmd.Run()
    return stdout.String(), stderr.String(), err
}

func main() {
    out, errout, err := Shellout("ls -ltr")
    if err != nil {
        log.Printf("error: %v\n", err)
    }
    fmt.Println("--- stdout ---")
    fmt.Println(out)
    fmt.Println("--- stderr ---")
    fmt.Println(errout)
}

edited Dec 6, 2022 at 9:37

answered Apr 6, 2017 at 5:33

typetetris

4,86519 silver badges34 bronze badges

10 Comments

Sean Pianka Over a year ago

Fantastic answer, this should be at the top. Having the ability to have a Golang error, stdout, and stderr clearly separated is the best combination available in this post.

Helmut Kemper Over a year ago

Fantastic answer 2

Matt Welke Over a year ago

I like this helper function for when you have a string and just want to use it as a command. Maybe not the safest thing to run in prod (maybe that's why the std lib approach uses varargs, not string), but useful for quick stuff. The only change I would suggest would be to re-arrange the return types so that error is last, which would be the Go convention for returning errors. VS Code complained about this to me when I copy and pasted this in.

typetetris Over a year ago

I always thought code snippets here on stackoverflow are just examples, you should alter as you see fit. But you are right in all regards.

typetetris Over a year ago

The most important point in my opinion: If the value for the command parameter is constructed from untrusted data, you really must sanitize it. Otherwise you are building a remote code execution flaw/bug/error.

|

Jonathan Hall · Accepted Answer · 2019-04-03 11:53:07Z

13

This answer does not represent the current state of the Go standard library. Please take a look at @Lourenco's answer for an up-to-date method!

Your example does not actually read the data from stdout. This works for me.

package main

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

func main() {
    app := "/bin/ls"
    cmd, err := exec.Run(app, []string{app, "-l"}, nil, "", exec.DevNull, exec.Pipe, exec.Pipe)

    if (err != nil) {
       fmt.Fprintln(os.Stderr, err.String())
       return
    }

    var b bytes.Buffer
    io.Copy(&b, cmd.Stdout)
    fmt.Println(b.String())

    cmd.Close()
}

edited Apr 3, 2019 at 11:53

Jonathan Hall

80.5k19 gold badges162 silver badges206 bronze badges

answered May 31, 2011 at 3:01

jimt

26.5k8 gold badges74 silver badges61 bronze badges

2 Comments

ggorlen Over a year ago

@ChrisBunch might consider switching the checkmark as a service to the community.

Kirill Vladi Over a year ago

What is a package named "exec"? Why don't you use "os/exec" from the standard library? And keep using variables like os.DevNull instead of your exec.DevNull

Jeff Learman · Accepted Answer · 2022-08-29 20:04:34Z

9

// Wrap exec, with option to use bash shell

func Cmd(cmd string, shell bool) []byte {

    if shell {
        out, err := exec.Command("bash", "-c", cmd).Output()
        if err != nil {
            panic("some error found")
        }
        return out
    } else {
        out, err := exec.Command(cmd).Output()
        if err != nil {
            panic("some error found")
        }
        return out
    }
}

you may try this .

edited Aug 29, 2022 at 20:04

Jeff Learman

3,3991 gold badge26 silver badges33 bronze badges

answered Jan 4, 2015 at 9:46

qing

1111 silver badge3 bronze badges

3 Comments

Sonia Hamilton Over a year ago

Thanks qing this is a useful function for running miscellaneous commands via the shell, without having to split up all the args like in @Lourenco 's answer

Michael Whatcott Over a year ago

Obviously this is no longer a cross-platform solution, but the question is specific to shell commands.

Jeff Learman Over a year ago

Note that if shell is false, arguments can't be passed to the command.

injartnak · Accepted Answer · 2023-02-16 09:37:50Z

4

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("cmd", "/C", "dir")
    output, err := cmd.Output()

    if err != nil {
        fmt.Println("Error executing command:", err)
        return
    }

    fmt.Println(string(output))
}

Use the exec.Command function to create a new cmd process with the /C flag and the dir command as its argument Capture output with output() method and print it.

answered Feb 16, 2023 at 9:37

injartnak

411 bronze badge

Comments

Xeoncross · Accepted Answer · 2017-01-07 00:58:24Z

Here is a simple function that will run your command and capture the error, stdout, and stderr for you to inspect. You can easily see anything that might go wrong or be reported back to you.

// RunCMD is a simple wrapper around terminal commands
func RunCMD(path string, args []string, debug bool) (out string, err error) {

    cmd := exec.Command(path, args...)

    var b []byte
    b, err = cmd.CombinedOutput()
    out = string(b)

    if debug {
        fmt.Println(strings.Join(cmd.Args[:], " "))

        if err != nil {
            fmt.Println("RunCMD ERROR")
            fmt.Println(out)
        }
    }

    return
}

You can use it like this (Converting a media file):

args := []string{"-y", "-i", "movie.mp4", "movie_audio.mp3", "INVALID-ARG!"}
output, err := RunCMD("ffmpeg", args, true)

if err != nil {
    fmt.Println("Error:", output)
} else {
    fmt.Println("Result:", output)
}

I've used this with Go 1.2-1.7

IStranger · Accepted Answer · 2022-04-12 17:00:40Z

3

If you want run long-running script asynchronously with execution progress, you may capture command output using io.MultiWriter and forward it to stdout/stderr:

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

var stdoutBuf, stderrBuf bytes.Buffer

cmd := exec.Command("/some-command")

cmd.Stdout = io.MultiWriter(os.Stdout, &stdoutBuf)
cmd.Stderr = io.MultiWriter(os.Stderr, &stderrBuf)

err := cmd.Start()  // Starts command asynchronously

if err != nil {
    fmt.Printf(err.Error())
}

edited Apr 12, 2022 at 17:00

answered Apr 11, 2022 at 23:08

IStranger

2,08119 silver badges25 bronze badges

Comments

Clare Chu · Accepted Answer · 2020-05-05 06:32:45Z

1


import (
    "github.com/go-cmd/cmd"
)

const DefaultTimeoutTime = "1m"

func RunCMD(name string, args ...string) (err error, stdout, stderr []string) {
    c := cmd.NewCmd(name, args...)
    s := <-c.Start()
    stdout = s.Stdout
    stderr = s.Stderr
    return
}

go test

import (
    "fmt"
    "gotest.tools/assert"
    "testing"
)

func TestRunCMD(t *testing.T) {
    err, stdout, stderr := RunCMD("kubectl", "get", "pod", "--context", "cluster")
    assert.Equal(t, nil, err)
    for _, out := range stdout {
        fmt.Println(out)
    }
    for _, err := range stderr {
        fmt.Println(err)
    }
}

answered May 5, 2020 at 6:32

Clare Chu

7787 silver badges8 bronze badges

Comments

Tony Veijalainen · Accepted Answer · 2011-05-31 08:25:42Z

I did not get the Rosetta example to work in my Windows Go. Finally I managed to go past the old format of the Subprocess with this command to start outfile in notepad in windows. The wait constant parameter mentioned in one manual did not exist so I just left out Wait as the user will close the program by themself or leave it open to reuse.

p, err := os.StartProcess(`c:\windows\system32\notepad.EXE`,
    []string{`c:\windows\system32\notepad.EXE`, outfile},
    &os.ProcAttr{Env: nil, Dir: "", Files:  []*os.File{os.Stdin, os.Stdout, os.Stderr}})

You would change the os.Stdout.. to os.Pipe as previous answer

EDIT: I got it finally from godoc os Wait, that Wait has changed to method of and I succeeded to do:

   defer p.Wait(0)

Then I decided finally to put

   defer p.Release()

instead.

Raaka · Accepted Answer · 2024-06-25 19:33:20Z

0

I ended up doing this to get exit error code, command output and error:

parts := strings.Split("netstat -tupln", " ")
cmd := exec.Command(parts[0], parts[1:]...)
out, err := cmd.Output()
exitCode := cmd.ProcessState.ExitCode()

with the help from answers above (and other questions on stackoverflow), hope this helps someone.

answered Jun 25, 2024 at 19:33

Raaka

4101 gold badge5 silver badges17 bronze badges

Comments

Gerassimos Mitropoulos · Accepted Answer · 2024-11-07 14:13:36Z

0

Here's a great alternative using the cmdx library that makes executing commands and capturing output simpler and more intuitive:

package main

import (
    "github.com/kgs19/cmdx"
    "log"
)

func main() {
    command := "date"
    args := []string{"+%H:%M"}
    out, err := cmdx.RunCommandReturnOutput(command, args...)
    if err != nil {
        log.Fatalf("Error executing 'date' command: %v", err)
    }
    println("cmd output: " + out)
}

Explanation

cmdx.RunCommandReturnOutput(command, args...): This function runs the specified command with the given arguments and returns the output as a string.

For more information, check out the GitHub repository.

answered Nov 7, 2024 at 14:13

Gerassimos Mitropoulos

1742 silver badges11 bronze badges

Collectives™ on Stack Overflow

Exec a shell command in Go

11 Answers 11

6 Comments

10 Comments

2 Comments

3 Comments

Comments

Comments

Comments

Comments

Comments

Comments

Explanation

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

11 Answers 11

6 Comments

10 Comments

2 Comments

3 Comments

Comments

Comments

Comments

Comments

Comments

Comments

Explanation

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related