🧠 Traps & Signals

Signals are the primary mechanism the operating system uses to interrupt, terminate, or notify processes. Traps allow shell scripts to intercept these signals and perform cleanup, logging, or controlled shutdowns. Understanding traps is essential for writing robust, production‑grade automation.

🎓 Who This Is For

Engineers writing long‑running or stateful scripts
DevOps/SRE teams managing daemons, cron jobs, and CI/CD tasks
Sysadmins handling cleanup, rollback, or resource management
Anyone needing predictable shutdown behavior in shell scripts

🧩 Role in the Ecosystem

Signals are used by:

The OS to terminate processes (SIGTERM, SIGKILL)
Users (Ctrl+C → SIGINT)
Supervisors (systemd, Docker, Kubernetes)
Shells to propagate pipeline failures
Scripts to coordinate child processes

Traps allow scripts to intercept these signals and run custom logic before exiting.

🧩 Key Concepts

1. Signals

Common signals:

SIGINT — interrupt (Ctrl+C)
SIGTERM — polite termination
SIGKILL — forced termination (cannot be trapped)
SIGHUP — terminal closed / reload
EXIT — pseudo‑signal triggered on script exit

2. Traps

A trap registers a handler:

trap 'cleanup' EXIT
trap 'echo interrupted; exit 130' INT TERM

3. EXIT Trap

Runs regardless of how the script ends (success, error, signal):

trap 'rm -f "$TMPFILE"' EXIT

4. Propagation

Signals propagate through pipelines and subshells, but behavior differs across shells.

🔧 Notable Techniques

Cleanup on Exit

cleanup() {
  rm -f "$TMPFILE"
}
trap cleanup EXIT

Graceful Shutdown

trap 'echo "Stopping..."; kill "$child"; exit 0' TERM

Handling Ctrl+C

trap 'echo "Interrupted"; exit 130' INT

Temporary Resource Management

TMPDIR="$(mktemp -d)"
trap 'rm -rf "$TMPDIR"' EXIT

Ignoring Signals

trap '' HUP

⚠️ Limitations & Pitfalls

SIGKILL cannot be trapped
Traps behave differently in subshells
Some shells reset traps inside pipelines
set -e interacts poorly with traps in some shells
EXIT traps may not run if the shell crashes
Bash and dash differ in how they propagate signals in pipelines

🧠 When to Use Traps

Cleaning up temporary files or directories
Stopping background jobs or child processes
Releasing locks or semaphores
Ensuring graceful shutdown in CI/CD
Handling user interrupts (Ctrl+C)
Managing long‑running scripts or daemons

❌ When Not to Use Traps

When relying on SIGKILL behavior
When cleanup must be guaranteed even on kernel‑level termination
When portability across shells is uncertain
When the script is extremely short‑lived

✅ Best Practices

Always clean up temporary files via trap 'rm -f ...' EXIT
Use explicit exit codes (130 for Ctrl+C)
Avoid complex logic inside traps
Document which signals your script handles
Test behavior under multiple shells
Prefer trap 'handler' INT TERM EXIT for robust shutdown
Avoid relying on traps inside pipelines or subshells

🧪 Testing Traps & Signals

trap 'echo "INT received"' INT
sleep 10

Test termination:

kill -TERM $$

Test cleanup:

TMPFILE=$(mktemp)
trap 'rm -f "$TMPFILE"' EXIT

🧠 Summary

Traps and signals provide controlled shutdown, cleanup, and error handling for shell scripts. They are essential for writing reliable automation, especially in long‑running or stateful environments. Used correctly, traps ensure predictable behavior even under interruption or termination.