Bash Error Handling

To build robust and reliable automation, error handling in bash scripts is essential. Without proper error handling a script may continue to run even after an error has occurred resulting in unexpected output or even system crashes.

To handle errors in a script, you can use the methods given below depending on the need:

1. Use set -e selectively: makes the script exit immediately if any command it runs exits with a non-zero status
2. Check Command Exit Codes: check its return code using $? and take appropriate actions based on the result.
3. Use Conditional Execution (|| with True Command): Allow to continue the script execution despite encountering errors.
4. Trap Errors with trap command: catch errors using signals, such as ERR, and define custom error-handling functions.

These various error-handling techniques work together to protect Bash scripts from unexpected issues, enabling you to build automation that doesn’t just run smoothly but also handles errors gracefully. To assist you, this article will discuss error handling in bash script elaborately. So let’s start!

Understanding the Importance of Error Handling in Bash

In any programming language, errors are inevitable. Errors can be caused by a variety of things, such as incorrect user input, incorrect data formats, and unexpected system conditions. If you don’t have proper error handling in place, you could end up with script errors, data corruption, and even system crashes.

The purpose of error handling in Bash is to:

1. Improve Script Reliability: Catch and handle errors correctly so that scripts do not crash or terminate suddenly.
2. Provide Effective Error Management: If an error occurs, you can display informative error messages that explain the error and provide guidance on how to fix it. This improves the user experience and avoids confusion.
3. Protect Data Integrity: Unhandled errors may cause data corruption or loss, so error handling helps to protect data integrity by not allowing scripts to modify or delete data.
4. Improve Debugging Efficiency: Error handling allows you to log error messages and related information, making debugging and troubleshooting easier. You can quickly find out where errors are coming from and take corrective actions.

Common Types of Errors in Bash Scripts

Several types of errors can occur in bash scripts. Each type has its characteristics and consequences. Here are some of the most common types of errors in bash scripts:

1. Syntactical Errors: These errors are caused by incorrect syntax in the bash code. For example, missing keywords, incorrect punctuation, or incorrect command structure can lead to syntax errors.
2. Runtime Errors: This type of error occurs during the execution of the script. It can be caused by unexpected conditions or by an invalid input. Common types of runtime errors in bash include: File not found errors, Invalid file permissions, and Division by zero errors.
3. Logic Errors: These errors are caused by faulty logic within the script. While they may not cause an immediate crash, they can lead to unpredictable behaviour. This type of error is more difficult to detect.
4. Input Errors: Input errors are caused by unexpected user inputs. Proper validation mechanisms should be implemented to handle diverse user inputs and prevent script failures.
5. Environmental Errors: Environmental errors result from dependencies or configuration issues. These errors impact the script’s interaction with its environment. Scripts relying on external factors may encounter errors if these dependencies are not present or configured correctly.

7 Error Handling Techniques in Bash Script

In bash scripting, several error-handling methods improve the robustness of the scripts. Here are some important error handling methods given and discussed below:

1. Using Conditional “if-else” Statement to Handle Error

In bash scripting, if else statement is one of the most useful techniques that can be used to handle errors and control the flow of the script according to certain conditions. If you use this structure in your script, you will be able to create a script that is responsive and can be changed depending on the situation.

To understand the concept, let’s first sum two numeric values based on the given positional input. Here’s a simple Bash script that sums two numbers using positional parameters:

#!/bin/bash

# Sum the two numbers using positional parameters
sum=$(( $1 + $2 ))

# Print the result
echo "Sum of $1 and $2 is: $sum"

In the first scenario, the script “sum.sh” is executed with two numeric inputs: 3 and 4, and it returns a valid output. However, in the second scenario, three different numeric values are given but the code is designed to only take two positional arguments. This may result in a misleading return value. In the last scenario, one numeric and one string value are provided, but the code requires only a numeric value to perform the sum. Therefore, except for the first case, the return value may not be accurate and can mislead someone.

Now to handle those errors, you can incorporate an if-else statement in the existing code.

Below is a simple Bash script that uses if-else statement to handle errors efficiently:

#!/bin/bash

# Check if two arguments are provided
if [ $# -ne 2 ]; then
    echo "Error: Please provide exactly two numeric arguments."
    exit 1
fi

# Check if both arguments are numeric
if [[ "$1" =~ ^[0-9]+$ ]] && [[ "$2" =~ ^[0-9]+$ ]]; then
    # Perform the sum and print the result
    sum=$(( $1 + $2 ))
    echo "Sum of $1 and $2 is: $sum"
else
    echo "Error: Both arguments must be numeric."
fi 

As the image suggests, the updated bash script successfully handles the error for the last two cases.

Using Conditional “if-else” Statement and “AND” Operator to Handle Error

You can accomplish the same by only using if-else statement and the AND operator. Here is a reference code, you can follow:

#!/bin/bash

# Check if two arguments are provided and both are numeric
if [[ $# -eq 2 && "$1" =~ ^[0-9]+$ && "$2" =~ ^[0-9]+$ ]]; then
    # Perform the sum and print the result
    sum=$(( $1 + $2 ))
    echo "Sum of $1 and $2 is: $sum"
else
    echo "Error: Please provide exactly two numeric arguments."
fi

As you can see, upon execution the code returns the same output as it did in the previous code for all three cases.

2. Using PIPESTATUS to Handle the Error in Pipeline

In Bash, the PIPESTATUS array allows you to access the exit status of each command in a pipeline. It allows you to know which command has failed in your script based on the exit status. The exit status is a number that is returned to the operating system after the execution of the command or a script.

In the Unix-like operating system, including Linux, there is a convention where an exit status value of 0 indicates that the command executed successfully, and any value that is not zero indicates that the command encountered an error or some kind of failure.

To use PIPESTATUS to find the failed command in a pipeline, use the following code and handle the error:

#!/bin/bash

# Example commands in a pipeline
command1=" ls /home/miran"
command2="grep LinuxSimply.txt"

# Execute the pipeline and capture the exit status
${command1} | ${command2}
pipeline_status=("${PIPESTATUS[@]}")

# Check the exit status of each command
if [ "${pipeline_status[0]}" -ne 0 ]; then
  echo "Error: Command 1 failed with exit status ${pipeline_status[0]}"
fi

if [ "${pipeline_status[1]}" -ne 0 ]; then
  echo "Error: Command 2 failed with exit status ${pipeline_status[1]}"
else
  echo "Pipeline executed successfully!"
fi

While running the abovementioned bash code, the ls /home/miran exists but LinuxSimply.txt does not exist in the given directory. So the second command failed while executing the bash file. The exit status of the failing command2 is 1 in this case. Thus, the code returns “Error: Command 2 failed with exit status 1” in the command line.

3. Using the Exit Status Code to Handle Error

The exit status code plays a vital role in error handling in bash scripts. When a command executes, its output status is saved in the $? variable. A value of 0 indicates that the command executed successfully, while a non-zero value indicates that the command failed.

You can always use the exit status code to handle the error. Here is an example of how you can handle an error using the exit status code:

#!/bin/bash

# Example command that may fail
ls /home/miran/ | grep "LinuxSimply.txt" 2>/dev/null

# Check the exit status
if [ $? -ne 0 ]; then
  echo "Error: Command failed with exit status $?" >&2
  exit 1  # Exit the script with a non-zero status
fi

# Continue with the rest of the script for successful execution
echo "Command executed successfully."

Since the specified directory /home/miran/ exists but does not contain the file named LinuxSimply.txt, the command fails and ultimately returns a zero exit status code. As you can see from the image, the zero exit status code is displayed on the terminal with an error message stating that the command failed.

4. Using “set -e” to Stop the Execution

By using the set -e parameter in a bash script, you can terminate the script automatically if any of the commands in the script exits with non-zero status. This can improve the reliability of the script by stopping execution when it encounters an error, without having to explicitly check the exit status after every command.

Here is an example of handling error using set -e command:

#!/bin/bash

# Enable the 'set -e' option
set -e

echo "This line will be executed as there is no error yet."

# Example commands that may fail
ls /home/miran/ | grep "LinuxSimply.txt" 2>/dev/null

# The script will automatically exit if the above command fails
# and the following commands won't be executed.

# Continue with the rest of the script for successful execution
echo "This line won't be reached if there's an error."

Since there is no LinuxSimply.txt in the /home/miran/ directory. The given code returns a non-zero status in ls /home/miran/ | grep "LinuxSimply.txt" 2>/dev/null line. And there is no line print except “This line will be executed as there is no error yet.” because it was executed before encountering the error.

5. Using “trap” Command with ERR Argument

The trap command is another way to handle errors in a bash script. With the help of ERR signal built-in with the trap command,  you can define actions to be taken whenever any error occurs.

To handle errors, the Bash script below demonstrates the use of the trap command with the ERR signal:

#!/bin/bash

# Function to handle errors
handle_error() {
  echo "Error: Command failed with exit status $?" >&2
  exit 1
}

# Set up trap to call handle_error on ERR signal
trap 'handle_error' ERR

echo "This line will be executed as there is no error yet."

# Example commands that may fail
ls /home/miran/ | grep "LinuxSimply.txt" 2>/dev/null

# The script will automatically call handle_error if the above command fails
# and the following commands won't be executed.
echo "This line won't be reached if there's an error."

Since the LinuxSimply.txt file does not exist in the current directory, ls /home/miran/ | grep "LinuxSimply.txt" 2>/dev/null occurs an error and the code returns an error with exit status using the trap command and ERR argument.

6. Combining “set” and “trap” Commands for Error Handling

You can also combine both “set -e” and “trap” commands to handle errors. This action will enable you to stop the execution once the command finds an error and returns a customized error message.

Here’s an example of combining the set -e and trap commands in a Bash script:

#!/bin/bash

# Enable exit-on-error mode
set -e

# Function to be executed on error or script termination
cleanup_function() {
    echo "An error occurred. Cleaning up..."
    # Add cleanup actions here
}

# Trap the ERR signal and call the cleanup_function
trap 'cleanup_function' ERR

# Your script logic goes here
echo "Executing script..."

# Simulate a command failure
ls /nonexistent-directory

echo "Script completed successfully."

As you can see from the image given above, the error occurs due to the /nonexistent-directory, thus the trap command with the help of ERR argument returns a customized error message to the terminal.

7. Allowing Script Execution Despite Errors

As you already know, a code’s set -e command allows you to terminate the execution if any error occurs. However, You can use the true command along with conditional execution (||) to allow script execution to continue despite errors. Here’s an example:

#!/bin/bash

set -e 

# Your script logic goes here
echo "Executing script..."

# Simulate a command failure but continue execution
ls /nonexistent-directory || true

# Another command that may fail
echo "Attempting another command..."
cat /nonexistent-file

echo "This line will not print if an error occurred and there is no true command in the error line."

As shown in the image, when using the “ls” command, there is an error. Because the directory “/nonexistent-directory” does not exist. However, since the “true” command is used, the code continues to execute. But when the interpreter encounters the “cat /nonexistent-file” command, it stops executing the file because the file does not exist and cannot be read.

Conclusion

In conclusion, error handling is one of the most important aspects of Bash scripting. It ensures that scripts can handle unexpected events smoothly. Scriptwriters can use mechanisms like set -e, conditional execution, and trap command to balance the need for robust error detection with the need to maintain script continuity. This article has discussed some effective ways to handle errors in bash script. If you have further questions or confusion related to error handling in bash, feel free to comment below. Thank you!

People Also Ask

How does Bash handle errors?

There are several error-handling mechanisms in bash. For example, set -e allows you to exit on-error mode. If any command returns non-zero, the script will terminate. However, you can override this behavior with || true to continue executing the script despite errors.

The trap command lets you specify what to do when you receive certain signals. For example, if you receive ERR, you can define a cleanup function. Then, you can trap this ERR signal. This way, you can perform the necessary actions when you encounter ERR.

All of these features work together to provide you with the flexibility of error handling within bash scripts.

How do I trap errors in Bash?

In Bash, you can trap errors using the trap command, which allows you to define actions that should be taken when certain signals are received.

To trap errors, you specifically target the ERR signal. Here’s a concise example:

#!/bin/bash

# Function to be executed on error
cleanup_function() {
    echo "An error occurred. Cleaning up..."
    # Add cleanup actions here
}

# Trap the ERR signal and call the cleanup_function
trap 'cleanup_function' ERR

# Your script logic goes here
echo "Executing script..."

# Simulate a command failure
some_command_that_might_fail

# Rest of the script
echo "Script completed."

In this code, in place of some_command_that_might_fail, write your code here to effectively handle the error with the trap command with the ERR argument.

What is exit 1 in Bash?

“exit 1” is a command used in bash to exit a script or a shell session with an exit status of 1. In the context of Bash scripting, exit statuses are numerical values returned by executed commands. Where 0 typically indicates success and non-zero values indicate failure. On the other hand, an exit status of 1 is used to indicate that a command or script failed to execute correctly or encountered an error.

Here is an example of how to use exit 1 in a bash script:

#!/bin/bash
# Your script logic goes here

# Check for a specific condition
if [ ! -f "some_file.txt" ]; then
    echo "Error: File not found."
    exit 1
fi

# Continue script execution
echo "File found. Script completed successfully."

Here if the script doesn’t find the file “some _file.txt”, the script will print an error and exit with 1. This means that the calling environment will know that the script has encountered an error.

How do I stop Bash from errors?

To stop bash from error, use the set -e command at the beginning of your code:

# Enable exit-on-error mode
set -e

# Your script logic goes here

Thus the script will stop executing if encounters any error. However, it is generally recommended to handle errors rather than bypassing them entirely.  Because errors are essential for identifying and addressing issues in your scripts.

Related Articles

• Print and Handle Error with Bash Exit Code [Easy Guide]
• How to Exit on Error in Bash Script? [6+ Methods]
• How to Handle Error with “trap ERR” in Bash? [Easy Steps]
• [Solved] “No such file or directory” Error in Bash
• [Fixed] “bad substitution” Error in Bash
• [SOLVED] /bin/bash^M: bad interpreter: No such file or directory
• [Fixed] “bash: syntax error near unexpected token” Error
• [Fixed!] “syntax error: unexpected end of file” in Bash
• [Solved!] Handling Error with TRY CATCH Block in Bash

---

<< Go Back to Bash Error Handling and Debugging | Bash Scripting Tutorial