Signal Handling and Traps – in Shell Scripting

What You’ll Learn 📚

• Understanding signals in Unix/Linux systems
• Using traps to handle signals in shell scripts
• Writing scripts that respond to user interruptions
• Debugging and troubleshooting common issues

Introduction to Signals

In the world of Unix/Linux, signals are a way for processes to communicate with each other. Think of them as a way to send a message to a program, telling it to stop, continue, or handle an event. Signals are identified by numbers, but they also have names like SIGINT (interrupt), SIGTERM (terminate), and SIGKILL (kill).

💡 Lightbulb Moment: Imagine signals as phone calls to your script, where each call has a specific purpose or message!

Key Terminology

• Signal: A notification sent to a process to trigger a predefined action.
• Trap: A mechanism to catch and handle signals within a script.
• SIGINT: Signal for interrupting a process (usually sent by pressing Ctrl+C).
• SIGTERM: Signal for terminating a process gracefully.

Starting with the Simplest Example

#!/bin/bash

# Trap SIGINT (Ctrl+C) and call a function
trap 'echo "Caught SIGINT! Exiting gracefully..."; exit' SIGINT

# Infinite loop to keep the script running
while true; do
    echo "Running... (Press Ctrl+C to stop)"
    sleep 1
done

Progressively Complex Examples

#!/bin/bash

# Trap SIGINT and SIGTERM
trap 'echo "Caught SIGINT!"; exit' SIGINT
trap 'echo "Caught SIGTERM!"; exit' SIGTERM

# Infinite loop
while true; do
    echo "Running..."
    sleep 1
done

#!/bin/bash

# Ignore SIGINT
trap '' SIGINT

# Infinite loop
while true; do
    echo "Try to stop me!"
    sleep 1
done

#!/bin/bash

# Function to clean up
cleanup() {
    echo "Cleaning up..."
    # Add cleanup commands here
    exit
}

# Trap SIGINT and call cleanup
trap cleanup SIGINT

# Infinite loop
while true; do
    echo "Running..."
    sleep 1
done

Common Questions and Answers

1. What is a signal in Unix/Linux?

   A signal is a notification sent to a process to trigger a specific action, like stopping or continuing execution.

2. How do I trap a signal in a shell script?

   Use the trap command followed by a command or function and the signal name. For example: trap 'echo "Caught SIGINT"' SIGINT.

3. Can I trap multiple signals?

   Yes, you can set up multiple trap commands for different signals in your script.

4. What happens if I ignore a signal?

   If you ignore a signal, the default action won’t occur. For example, ignoring SIGINT means Ctrl+C won’t stop your script.

5. Why would I want to handle signals?

   Handling signals allows your script to clean up resources, save data, or perform other tasks before exiting.

Troubleshooting Common Issues

⚠️ Warning: Be careful when ignoring signals like SIGINT as it can make your script difficult to stop!

• Issue: My trap isn’t working.

  Solution: Ensure the trap command is placed before the code that might trigger the signal.

• Issue: The script exits immediately after a signal.

  Solution: Check if your trap command includes an exit statement. If so, it will terminate the script.

Try It Yourself! 🛠️

Now it’s your turn! Modify one of the examples to handle a different signal, like SIGHUP, and see how it behaves. Experiment with adding cleanup tasks in the cleanup function.

Additional Resources

• GNU Bash Manual – Signals
• Bash Beginner’s Guide – Traps

Keep experimenting and happy scripting! 🌟