How to check command exit code

Introduction

In the world of Golang programming, understanding how to check command exit codes is crucial for building reliable and robust command-line applications. This tutorial will guide developers through the essential techniques of handling command execution results, error detection, and advanced error management strategies in Golang.

Skills Graph

Exit Code Basics

What is an Exit Code?

An exit code is a numeric value returned by a command or program when it finishes executing, indicating whether the operation was successful or encountered an error. In Linux and Unix-like systems, exit codes provide a standardized way to communicate the status of a program's execution.

Standard Exit Code Conventions

Understanding Exit Code Mechanics

Simple Exit Code Example in Golang

package main

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

func main() {
    cmd := exec.Command("ls", "/nonexistent")
    err := cmd.Run()

    if err != nil {
        // Check exit code
        if exitError, ok := err.(*exec.ExitError); ok {
            fmt.Printf("Command failed with exit code: %d\n", exitError.ExitCode())
        }
    }
}

Why Exit Codes Matter

Exit codes are crucial for:

• Script error handling
• Automated system monitoring
• Debugging and troubleshooting
• Chaining command execution

At LabEx, we emphasize understanding these fundamental system interactions to build robust and reliable software solutions.

Command Exit Handling

Basic Exit Code Checking in Golang

Using exec.Command

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "/")
    err := cmd.Run()

    if err != nil {
        fmt.Println("Command failed:", err)
    }
}

Detailed Exit Status Handling

Extracting Exit Codes

package main

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

func main() {
    cmd := exec.Command("grep", "nonexistent", "file.txt")
    err := cmd.Run()

    if err != nil {
        if exitError, ok := err.(*exec.ExitError); ok {
            // Extract system-level exit status
            status := exitError.Sys().(syscall.WaitStatus)
            fmt.Printf("Exit Code: %d\n", status.ExitStatus())
        }
    }
}

Command Execution Workflow

Exit Code Handling Strategies

Advanced Error Handling Example

package main

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

func runCommand(command string, args ...string) {
    cmd := exec.Command(command, args...)

    err := cmd.Run()
    if err != nil {
        if exitError, ok := err.(*exec.ExitError); ok {
            status := exitError.Sys().(syscall.WaitStatus)

            switch status.ExitStatus() {
            case 1:
                log.Println("Command failed with specific error")
            case 2:
                log.Println("Misuse of shell command")
            default:
                log.Printf("Unknown error: Exit code %d", status.ExitStatus())
            }
        }
    }
}

func main() {
    runCommand("ls", "/nonexistent")
}

Best Practices

• Always check command execution errors
• Use specific error handling strategies
• Log exit codes for debugging
• Handle different exit scenarios gracefully

At LabEx, we recommend comprehensive error handling to create robust command-line applications.

Advanced Error Handling

Context-Aware Error Management

Comprehensive Error Handling Pattern

package main

import (
    "context"
    "fmt"
    "log"
    "os/exec"
    "time"
)

func executeCommandWithTimeout(command string, timeout time.Duration) error {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    cmd := exec.CommandContext(ctx, "bash", "-c", command)

    output, err := cmd.CombinedOutput()
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            return fmt.Errorf("command timed out: %v", err)
        }

        if exitError, ok := err.(*exec.ExitError); ok {
            return fmt.Errorf("command failed with exit code %d: %s",
                exitError.ExitCode(), string(output))
        }

        return err
    }

    return nil
}

func main() {
    err := executeCommandWithTimeout("sleep 10", 5*time.Second)
    if err != nil {
        log.Println("Execution error:", err)
    }
}

Error Classification Strategy

Error Handling Techniques

Advanced Error Logging and Reporting

package main

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

type CommandResult struct {
    Success     bool
    ExitCode    int
    Output      string
    ErrorDetail string
}

func executeAndAnalyzeCommand(command string) CommandResult {
    cmd := exec.Command("bash", "-c", command)

    output, err := cmd.CombinedOutput()
    result := CommandResult{
        Output: string(output),
    }

    if err != nil {
        result.Success = false

        if exitError, ok := err.(*exec.ExitError); ok {
            status := exitError.Sys().(syscall.WaitStatus)
            result.ExitCode = status.ExitStatus()
            result.ErrorDetail = fmt.Sprintf("Command failed with exit code %d", result.ExitCode)
        } else {
            result.ErrorDetail = err.Error()
        }
    } else {
        result.Success = true
    }

    return result
}

func main() {
    result := executeAndAnalyzeCommand("ls /nonexistent")

    if !result.Success {
        log.Printf("Command Execution Failed: %s", result.ErrorDetail)
        log.Printf("Exit Code: %d", result.ExitCode)
        log.Printf("Output: %s", result.Output)
    }
}

Error Handling Best Practices

• Use context for timeout management
• Implement comprehensive error parsing
• Log detailed error information
• Create custom error types when necessary

At LabEx, we emphasize creating robust error handling mechanisms that provide clear insights into command execution failures.

Summary

By mastering command exit code handling in Golang, developers can create more resilient and error-tolerant applications. The techniques explored in this tutorial provide a comprehensive approach to managing command execution, interpreting system-level responses, and implementing sophisticated error handling mechanisms that enhance overall software reliability.