It's easy to determine if the exit code was 0 or something else. In the first case, cmd.Wait() will return nil (unless there is another error while setting up the pipes).

Unfortunately, there is no platform independent way to get the exit code in the error case. That's also the reason why it isn't part of the API. The following snippet will work with Linux, but I haven't tested it on other platforms:

package main


import "os/exec"
import "log"
import "syscall"


func main() {
cmd := exec.Command("git", "blub")


if err := cmd.Start(); err != nil {
log.Fatalf("cmd.Start: %v", err)
}


if err := cmd.Wait(); err != nil {
if exiterr, ok := err.(*exec.ExitError); ok {
log.Printf("Exit Status: %d", exiterr.ExitCode())
} else {
log.Fatalf("cmd.Wait: %v", err)
}
}
}

Just follow the api docs to find out more :)

Here's my enhanced version based on @tux21b 's answer

utils/cmd.go

package utils


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


const defaultFailedCode = 1


func RunCommand(name string, args ...string) (stdout string, stderr string, exitCode int) {
log.Println("run command:", name, args)
var outbuf, errbuf bytes.Buffer
cmd := exec.Command(name, args...)
cmd.Stdout = &outbuf
cmd.Stderr = &errbuf


err := cmd.Run()
stdout = outbuf.String()
stderr = errbuf.String()


if err != nil {
// try to get the exit code
if exitError, ok := err.(*exec.ExitError); ok {
ws := exitError.Sys().(syscall.WaitStatus)
exitCode = ws.ExitStatus()
} else {
// This will happen (in OSX) if `name` is not available in $PATH,
// in this situation, exit code could not be get, and stderr will be
// empty string very likely, so we use the default fail code, and format err
// to string and set to stderr
log.Printf("Could not get exit code for failed program: %v, %v", name, args)
exitCode = defaultFailedCode
if stderr == "" {
stderr = err.Error()
}
}
} else {
// success, exitCode should be 0 if go is ok
ws := cmd.ProcessState.Sys().(syscall.WaitStatus)
exitCode = ws.ExitStatus()
}
log.Printf("command result, stdout: %v, stderr: %v, exitCode: %v", stdout, stderr, exitCode)
return
}

I have tested it on OSX, if it's not working as expected on other platforms, please tell me so we can make it better.

Since golang version 1.12, the exit code is available natively and in a cross-platform manner. See ExitError and ExitCode().

ExitCode returns the exit code of the exited process, or -1 if the process hasn't exited or was terminated by a signal.

if err := cmd.Run() ; err != nil {
if exitError, ok := err.(*exec.ExitError); ok {
return exitError.ExitCode()
}
}

September 2019, Go 1.13 introduced errors.As which supports error "unwrapping" - handy for finding precise errors in a nested call-chain.

So to extract and inspect the two most common errors when running an external command:

• os.PathError
• exec.ExitError

err := cmd.Run()


var (
ee *exec.ExitError
pe *os.PathError
)


if errors.As(err, &ee) {
log.Println("exit code error:", ee.ExitCode()) // ran, but non-zero exit code


} else if errors.As(err, &pe) {
log.Printf("os.PathError: %v", pe) // "no such file ...", "permission denied" etc.


} else if err != nil {
log.Printf("general error: %v", err) // something really bad happened!


} else {
log.Println("success!") // ran without error (exit code zero)
}

New package github.com/bitfield/script makes exec a LOT easier and has some really great added features to it as well. Check it out.

In this example I run two commands. One that errors and one that doesn't. Both have output and both show the exit value.

package main


import (
"fmt"


"github.com/bitfield/script"
)


func main() {
for _, c := range []string{"git blub", "git version"} {
fmt.Println("running", c)
p := script.Exec(c)
fmt.Println("Exit Status:", p.ExitStatus())
if err := p.Error(); err != nil {
p.SetError(nil)
out,_:=p.Stdout()
fmt.Println(out)
} else {
out,_:=p.Stdout()
fmt.Println(out)
}
fmt.Println("--")
}
}

Output:

running git blub
Exit Status: 1
git: 'blub' is not a git command. See 'git --help'.


The most similar command is
pull


--
running git version
Exit Status: 0
git version 2.24.3 (Apple Git-128)


--

Recently run into this when developing my helper package.

Base on example code here: https://go-review.googlesource.com/c/go/+/213337/1/src/os/exec/example_test.go

func ExampleExitError() {
cmd := exec.Command("sleep", "-u")
err := cmd.Run()
var exerr *exec.ExitError
if errors.As(err, &exerr) {
fmt.Printf("the command exited unsuccessfully: %d\n", exerr.ExitCode())
}

The Exit Code

I end up doing the following for my own exec cmd wrapper:

// Return exit code
func (self *MyCmd) ExitCode() int {
var exitErr *exec.ExitError
if errors.As(self.Err, &exitErr) {
return exitErr.ExitCode()
}
// No error
return 0
}

self.Err is the return value from a exec.Command.Run(). Complete listing is here: https://github.com/J-Siu/go-helper/blob/master/myCmd.go

Text Error Message

While @colm.anseo answer take consideration of os.patherror, it doesn't give an error code(int), and IMHO should be handled separately. Instead text error message can be extract from execCmd.Stderr like follow:

func (self *MyCmd) Run() error {
execCmd := exec.Command(self.CmdName, *self.ArgsP...)
execCmd.Stdout = &self.Stdout
execCmd.Stderr = &self.Stderr
execCmd.Dir = self.WorkDir
self.CmdLn = execCmd.String()
self.Err = execCmd.Run()
self.Ran = true
ReportDebug(&self, "myCmd:", false, false)
ReportDebug(self.Stderr.String(), "myCmd:Stderr", false, false)
ReportDebug(self.Stdout.String(), "myCmd:Stdout", false, false)
return self.Err
}

self.Stderr is a bytes.Buffer and pass into execCmd before Run(). After execCmd.Run(), text err can be extracted with self.Stderr.String().