How to handle multiple signals in a trap command?

Handling Multiple Signals in a Trap Command

In the world of shell scripting, the trap command is a powerful tool that allows you to intercept and handle various signals that may be sent to your script. These signals can come from external sources, such as user input (e.g., Ctrl+C) or system events (e.g., process termination). When you're dealing with multiple signals in a script, it's important to understand how to handle them effectively.

Understanding Signals

Signals are a way for the operating system to communicate with running processes. Each signal has a unique number and a corresponding name, such as SIGINT (interrupt signal) or SIGTERM (termination signal). When a signal is sent to a process, the operating system interrupts the normal execution of the script and invokes the associated signal handler.

Handling Multiple Signals with Trap

The trap command in shell scripting allows you to define a signal handler that will be executed when a specific signal is received. To handle multiple signals, you can use the trap command with a list of signals separated by spaces.

Here's an example of how to handle SIGINT (Ctrl+C) and SIGTERM (termination signal) in a shell script:

#!/bin/bash

# Define a function to handle the signals
handle_signals() {
    echo "Caught signal. Exiting..."
    exit 1
}

# Trap SIGINT and SIGTERM signals
trap 'handle_signals' SIGINT SIGTERM

# Your script's main logic goes here
while true; do
    echo "Running script..."
    sleep 5
done

In this example, the handle_signals function is defined as the signal handler. The trap command is used to associate this function with the SIGINT and SIGTERM signals. When either of these signals is received, the handle_signals function will be executed, and the script will exit with a non-zero status code.

Handling Signals Individually

Sometimes, you may want to handle different signals in different ways. In such cases, you can define separate signal handlers for each signal:

#!/bin/bash

# Define signal handlers
handle_sigint() {
    echo "Caught SIGINT (Ctrl+C). Exiting..."
    exit 1
}

handle_sigterm() {
    echo "Caught SIGTERM (termination signal). Exiting..."
    exit 1
}

# Trap SIGINT and SIGTERM signals
trap 'handle_sigint' SIGINT
trap 'handle_sigterm' SIGTERM

# Your script's main logic goes here
while true; do
    echo "Running script..."
    sleep 5
done

In this example, the handle_sigint and handle_sigterm functions are defined as separate signal handlers for SIGINT and SIGTERM, respectively. The trap command is used to associate each handler with its corresponding signal.

Using Mermaid Diagrams to Visualize Signal Handling

To better understand the concept of signal handling in shell scripting, let's use a Mermaid diagram to illustrate the process:

graph LR A[Script Execution] --> B[Signal Received] B --> C{Trap Command} C --> D[Signal Handler 1] C --> E[Signal Handler 2] D --> F[Exit Script] E --> F

In this diagram, the script execution is represented by the A node. When a signal is received, it triggers the B node, which then leads to the C node, where the trap command is executed. Depending on the signal received, the appropriate signal handler (D or E) is invoked, and the script ultimately exits (F).

Real-World Examples

Imagine you're writing a script that monitors a system's resources, and you want to handle both the SIGINT (Ctrl+C) and SIGTERM (termination signal) signals. When the user presses Ctrl+C, you want to print a message and exit the script gracefully. When the script receives a termination signal, you want to clean up any temporary files or resources before exiting.

Here's how you could implement this in a shell script:

#!/bin/bash

# Define signal handlers
handle_sigint() {
    echo "Caught SIGINT (Ctrl+C). Exiting..."
    cleanup_resources
    exit 1
}

handle_sigterm() {
    echo "Caught SIGTERM (termination signal). Cleaning up and exiting..."
    cleanup_resources
    exit 1
}

# Function to clean up resources
cleanup_resources() {
    echo "Cleaning up temporary files..."
    rm -f /tmp/script_data.txt
}

# Trap SIGINT and SIGTERM signals
trap 'handle_sigint' SIGINT
trap 'handle_sigterm' SIGTERM

# Your script's main logic goes here
while true; do
    echo "Monitoring system resources..."
    # Perform resource monitoring tasks
    sleep 5
done

In this example, the handle_sigint and handle_sigterm functions are defined as signal handlers for SIGINT and SIGTERM, respectively. The cleanup_resources function is responsible for cleaning up any temporary files or resources used by the script.

When the user presses Ctrl+C or the script receives a termination signal, the appropriate signal handler is invoked, the resources are cleaned up, and the script exits.

By handling multiple signals in a trap command, you can ensure that your shell scripts are more robust and can gracefully handle various interruptions or termination events that may occur during their execution.