Error Handling In Linux Bash; set -e vs. trap

In Bash scripting, error handling is crucial to ensure that your scripts run reliably, especially when executing commands that could potentially fail. Two important tools for error handling in Bash are set -e and trap. Here's an explanation of both:

1. Using set -e (Exit on Error)

The set -e command causes the script to exit immediately if any command within the script fails (i.e., returns a non-zero exit status). This can be useful for scripts where you want to ensure that no errors are silently ignored.

Syntax:

set -e

Example:

#!/bin/bash
set -e

echo "This is a test script."
cp non_existent_file.txt destination/  # This will cause the script to exit here.
echo "This will not be executed."

In the above example, the script will exit immediately after the cp command fails, and the last echo statement will not be executed. The exit status of cp will be non-zero (indicating failure), so the script will terminate as expected.

2. Using trap for Error Handling

The trap command allows you to specify actions that should be performed when the script exits or when it receives certain signals. It is often used in conjunction with set -e to handle cleanup tasks (like removing temporary files or printing custom error messages) when a script encounters an error.

Syntax:

trap 'commands' SIGNAL

• SIGNAL is the signal or event you want to catch (e.g., EXIT, ERR).
• 'commands' are the commands that will be executed when the signal occurs.

Common Signals:

• EXIT: Triggered when the script exits, whether due to a successful or unsuccessful exit.
• ERR: Triggered when a command in the script returns a non-zero exit status (in combination with set -e).

Example with trap and set -e:

#!/bin/bash
set -e

# Define a cleanup function
cleanup() {
    echo "Cleaning up before exit..."
    # Remove temporary files or perform other cleanup actions
}

# Set up trap to call cleanup on script exit
trap cleanup EXIT

echo "Starting the script."

# Simulate an error
echo "Attempting to copy a non-existent file."
cp non_existent_file.txt destination/  # This will cause an error and exit.

echo "This will not be printed."

How it works:

• The script uses set -e to exit immediately when any command fails.
• The trap cleanup EXIT command sets up a trap to run the cleanup function when the script exits, whether normally or due to an error.
• If the cp command fails, the script will exit, and the cleanup function will be called before the script terminates.

3. Combining set -e and trap ERR

You can use the trap with the ERR signal to handle errors more gracefully, providing a more flexible error handling mechanism.

Example:

#!/bin/bash
set -e

# Define a function to handle errors
error_handler() {
    echo "An error occurred. Exiting the script..."
    # Perform additional error handling or logging
}

# Set up trap to handle errors
trap error_handler ERR

echo "Starting the script."

# Simulate an error
echo "Attempting to copy a non-existent file."
cp non_existent_file.txt destination/  # This will trigger the trap.

echo "This line will not be executed."

How it works:

• set -e ensures that the script exits on any error.
• trap error_handler ERR sets up a trap to invoke the error_handler function when any command fails (returns a non-zero exit status).
• If the cp command fails, the script triggers the error_handler, which provides a custom error message.

4. Advanced Example: Using set -e with Custom Error Messages

You can combine trap with set -e and custom messages to handle errors more effectively in more complex scripts. For example, you may want to print specific error messages or log the error before exiting.

Example:

#!/bin/bash
set -e

# Define a cleanup function
cleanup() {
    echo "Cleaning up before exit..."
}

# Define a function for custom error handling
error_handler() {
    echo "Error: A command failed with status $?."
    cleanup
    exit 1
}

# Set up trap for ERR signal
trap error_handler ERR

echo "Starting the script."

# Simulate an error with a command
echo "Simulating an error with a command."
invalid_command  # This command doesn't exist, so it will trigger the trap.

echo "This line won't be executed."

How it works:

• The script sets up trap error_handler ERR to invoke the error_handler function when a command fails.
• If an error occurs (such as the invalid_command in the script), the error_handler is called, printing a custom error message and cleaning up before the script exits with a status code of 1.

5. Important Notes

• Exit Codes: Every command in a script returns an exit code (0 for success, non-zero for failure). By default, Bash only exits on non-zero exit codes if set -e is used.
• Subshells and Pipelines: set -e does not cause the script to exit immediately when a command in a pipeline fails (unless you modify this behavior with set -o pipefail).

6. Using set -o pipefail

By default, Bash will not exit if a command fails in a pipeline. To make Bash exit if any command in a pipeline fails, you can use set -o pipefail.

Example:

#!/bin/bash
set -e
set -o pipefail

echo "This will cause the script to exit because of the failed command in the pipeline."
echo "First command" | invalid_command | echo "This will not run."

In this case, the script will exit when invalid_command fails in the pipeline.

---

Conclusion

• set -e is a simple and effective way to ensure that your Bash script terminates on any error.
• trap provides more flexibility, allowing you to handle errors gracefully, clean up resources, or log details before the script exits.
• For more robust error handling, use trap with ERR or EXIT to manage error handling in a centralized way, and combine with set -o pipefail to ensure the script handles errors in pipelines properly.

This combination of techniques will help make your Bash scripts more reliable and easier to debug.