Error Handling: Bulletproofing Your Scripts

The most dangerous kind of script is one that fails in the middle but keeps running. Imagine this script:

1. cd /important_data
2. rm -rf *

What happens if the first command fails? (Maybe the folder was deleted already). The script stays in its current directory (maybe your Home folder) and deletes everything!

To be a professional, you must write scripts that are "Self-Aware." They must detect failure immediately and stop before they cause damage.

In this final lesson on scripting, we will learn the "Safe Mode" settings and the "Trap" mechanism.

---

1. The "Safe Mode" Flags: set -euo pipefail

At the top of every professional script (immediately after the shebang), you should see these flags. They change Bash from a "Careless" language to a "Strict" one.

#!/bin/bash
set -euo pipefail

What they do:

• -e (Exit): Stop the script immediately if any command fails (returns non-zero).
• -u (Unset): Stop the script if you try to use a variable that hasn't been defined yet. (Stops typos like $FILES vs $FILE).
• -o pipefail: If any command in a "Pipe" (cmd1 | cmd2) fails, the whole script stops. Usually, Bash only checks if the last command in the pipe worked.

---

2. Dynamic Debugging: set -x

If a script is behaving strangely and you don't know why, don't just add 20 echo statements. Use "Trace Mode."

# Turn on tracing
set -x
./my_script.sh
# Bash will now print every line of code BEFORE it executes it.

# Turn off tracing inside a script
set +x

---

3. The trap: Cleanup or Death

If your script creates a temporary folder (/tmp/my_data), you want to make sure that folder is deleted whether the script finishes successfully OR crashes.

The trap command allows you to catch signals (like EXIT or SIGINT/Ctrl+C) and run code.

#!/bin/bash

# Define a cleanup function
cleanup() {
    echo "Cleaning up temporary files..."
    rm -rf /tmp/work_folder
}

# "Trap" the EXIT signal and run cleanup()
trap cleanup EXIT

# Script logic starts here
mkdir /tmp/work_folder
# If this command fails or you press Ctrl+C, 'cleanup' will run!
command_that_might_fail

---

4. Logical Error Handling (||)

If you want to run a specific bit of code only if a command fails, use the || (OR) operator.

# Try to create a dir; if fail, print error and exit script
mkdir /data/backup || { echo "Failed to create dir"; exit 1; }

---

5. Practical: The "Bulletproof" Backup Template

Here is a template you can use for almost any production-level bash script.

#!/bin/bash

# 1. Safe Mode
set -euo pipefail

# 2. Configuration
BACKUP_DIR="/mnt/backups"
LOG_FILE="/var/log/backup.log"

# 3. Cleanup Trap
cleanup() {
    echo "$(date): Clean up performed." >> "$LOG_FILE"
}
trap cleanup EXIT

# 4. Logic
echo "Starting backup to $BACKUP_DIR..."

# Check if directory exists
if [[ ! -d "$BACKUP_DIR" ]]; then
    echo "Error: Backup directory missing."
    exit 1
fi

# Run the task
tar -czf "$BACKUP_DIR/data.tar.gz" /home/sudeep/projects
echo "Backup Successful!"

---

6. Example: A Script Integrity Debugger (Python)

Sometimes the error in a script is a "Logical" error rather than a syntax error. Here is a Python script that executes a bash command and prints a detailed "Diagnostic Report" of why it failed.

import subprocess
import os

def debug_bash_command(cmd_string):
    """
    Runs a shell command and analyzes the failure.
    """
    print(f"Executing: {cmd_string}")
    
    # We use shell=True to allow pipes and redirections
    result = subprocess.run(cmd_string, shell=True, capture_output=True, text=True)
    
    if result.returncode == 0:
        print("[SUCCESS] Command finished perfectly.")
    else:
        print(f"[FAILED] Exit Code: {result.returncode}")
        print("-" * 30)
        print(f"STDOUT: {result.stdout.strip()}")
        print(f"STDERR: {result.stderr.strip()}")
        
        # Analyze specific codes
        if result.returncode == 127:
            print("\nHint: '127' usually means the command (binary) was NOT FOUND.")
        elif result.returncode == 126:
            print("\nHint: '126' means the file exists but is NOT EXECUTABLE.")
        elif "Permission denied" in result.stderr:
            print("\nHint: You likely need 'sudo' for this operation.")

if __name__ == "__main__":
    # Test with a failing command
    debug_bash_command("ls /root/secret_file")
    print("\n")
    debug_bash_command("unknown_tool --version")

---

7. Professional Tip: Check 'shellcheck'

Before you "Deploy" a script to a production server, run it through shellcheck. It is a world-class static analysis tool that finds bugs, security holes, and POSIX violations that you would never notice.

# Install it
sudo apt install shellcheck

# Audit your script
shellcheck my_automation.sh

---

8. Summary

A reliable script is a quiet script.

• set -e ensures failure isn't ignored.
• set -u prevents "Empty Variable" disasters.
• trap is your insurance policy for cleanup.
• set -x is your microscope for finding bugs.
• shellcheck is your final exam.

This concludes our module on Shell Scripting Mastery. You now possess the skills to automate your world, manage complex workflows, and build resilient infrastructure.

In the final module of this course, we will explore Essential System Services and Daemons (systemd, cron, and logs).

Quiz Questions

1. What is the danger of writing a script without set -e?
2. How do you ensure a temporary file is deleted even if the user cancels your script with Ctrl+C?
3. What does set -x do and how do you turn it back off inside a script?

---

End of Module 9. Proceed to Module 10: Essential System Services and Daemons.