Standards Decoded

At the heart of this city is the kernel, the all-powerful manager that directs traffic, ensures smooth communication, and enforces the rules. Just as a city’s mayor coordinates activities through various departments, the kernel executes commands that keep your computer running efficiently. Every time you launch an application, run a script, or perform a system task, the kernel is hard at work, processing your requests and executing commands to get the job done.

The os/exec package in Go is your toolkit for interacting with the kernel, allowing you to run external commands from within your Go programs. It’s like having a direct line to the city’s command center, giving you the power to execute tasks with precision and efficiency.

Customizing Command Execution

When it comes to interacting with the operating system in Go, the standard library provides a straightforward way to execute external processes. The os/exec package is the key to unlocking this functionality. In this blog post, we’ll explore how to use it to call external commands and tools.

Using the Cmd Struct and Run Method

The most straightforward way to execute an external process is by creating a Cmd struct and calling its Run method. This approach is perfect for calling OS utilities and tools, ensuring that your program doesn’t hang indefinitely waiting for the process to complete.

func main() {
  prc := exec.Command("ls", "-l")
  err := prc.Run()
  if err != nil {
    panic(err) 
  }
}

The Run method executes the command and waits until it completes. If the command exits with an error, the err value will not be nil, allowing you to handle errors accordingly.

If you run this command and nothing seems to happen, don’t worry—the command has been executed. In subsequent sections, we will look at how to capture the output of execution as well as how to manage user input from commands.

In case a command is not found in the OS binary registry, you can locate it using exec.LookPath("ls"), which helps ensure that your system functions as expected.

Handling Input/Output Streams

The output from executed commands is crucial and can be bound to any writer—be it Standard Output, a file, or any other writer implementing the io.Writer interface.

package main

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

func main() {
 prc := exec.Command("ls", "-a")
 out := bytes.NewBuffer([]byte{})
 prc.Stdout = out
 err := prc.Run()
 if err != nil {
   fmt.Println(err)
 }
 if prc.ProcessState.Success() {
   fmt.Println("Process run successfully with output:")
   fmt.Println(out.String())
 }
}

In this code snippet, we create a new exec.Command object representing the ls command process. We then use a bytes.Buffer object to capture the output of the command. The prc.Stdout field is set to out, meaning that any output from the command will be written there.

After running the command using prc.Run(), we check for errors. If there are none, we verify if the command ran successfully using prc.ProcessState.Success(), printing both a success message and the output.

Combined Output

You can also use a command’s CombinedOutput method, which assigns both standard output and standard error to a buffer.

func main() {
    cmd := exec.Command("ls", "-a")
    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Fatalf("cmd.Run() failed with %s\n", err)
    }
    fmt.Printf("combined out:\n%s\n", string(out))
}

This method simplifies capturing all output types from a command into one variable.

Interacting with External Bash Shells

The following program demonstrates how to interact with an external Bash shell using command execution and buffered I/O:

package main

import ( 
  "bufio"
  "fmt" 
  "os" 
  "log"
  "os/exec"
  "strings" 
  "errors"
) 

type Shell struct{} 

func (Shell) CmdFromString(p []string) (cmd *exec.Cmd, err error) {
 if len(p) == 0 { return nil, errors.New("endline clicked") }
 if len(p) == 1 { return exec.Command(p[0]), nil }
 return exec.Command(p[0], p[1:]...), nil 
} 

func main() {
 input := bufio.NewScanner(os.Stdin)
 shell := Shell{}
 for input.Scan() {
  cmd, err := shell.CmdFromString(strings.Fields(input.Text()))
  if err != nil { continue }
  
  out, err := cmd.CombinedOutput()
  if err != nil { log.Panic(err) }
  fmt.Printf("Output \n%s", out)
 }
}

This program allows users to enter commands interactively; as they type commands, it relays them to Bash and captures their outputs.

Error Handling and Exit Status

The os/exec package includes two primary error types: exec.Error and exec.ExitError. It’s essential to check for both types of errors and handle them accordingly:

Handling exec.Error: This error occurs when a command cannot be executed due to issues like being not found or not executable.
Handling exec.ExitError: This error arises when a command executes but returns a non-zero exit status indicating failure.