Linux shell uses trap command to handle program interrupts elegantly

#!/bin/bash

WORK_DIR="/tmp/backup_$(date +%Y%m%d)"

echo "Start backup..."
mkdir -p "$WORK_DIR"
echo "Create a temporary directory: $WORK_DIR"

echo "Copy the file..."
cp -r /path/to/data "$WORK_DIR/"
sleep 5  # Simulation time-consuming operation
echo "Compression packaging..."
tar -czf  "$WORK_DIR"
sleep 3  # Simulation time-consuming operation
echo "Clean up temporary files..."
rm -rf "$WORK_DIR"

echo "Backup is complete！"

on_interrupt() {
    echo -e "\nThe program was interrupted!"
    echo "Clean temporary files..."
    rm -rf "$WORK_DIR"
    exit 1
}

trap on_interrupt SIGINT

#!/bin/bash

WORK_DIR="/tmp/backup_$(date +%Y%m%d)"

# Define interrupt handling functionon_interrupt() {
    echo -e "\nThe program was interrupted!"
    echo "Clean temporary files..."
    rm -rf "$WORK_DIR"
    exit 1
}

# Setting up traptrap on_interrupt SIGINT

echo "Start backup..."
mkdir -p "$WORK_DIR"
echo "Create temporary directory: $WORK_DIR"

echo "Copy the file..."
cp -r /path/to/data "$WORK_DIR/"
sleep 5  # Simulation time-consuming operation
echo "Compression Packaging..."
tar -czf  "$WORK_DIR"
sleep 3  # Simulation time-consuming operation
echo "Clean temporary files..."
rm -rf "$WORK_DIR"

echo "Backup is complete!"

trap command signal

trap on_interrupt SIGINT SIGTERM

#!/bin/bash

# Define variablesDATA_FILE=""
TEMP_FILE=""
LOG_FILE=""

# Process Ctrl+Con_interrupt() {
    echo -e "\nReceived SIGINT, is closing gracefully..."
    cleanup
    exit 1
}

# Handle SIGTERMon_terminate() {
    echo -e "\nReceived SIGTERM, save the progress and exit..."
    save_progress
    cleanup
    exit 1
}

# Process normal exiton_exit() {
    echo "The program ends normally, clean up..."
    cleanup
}

# Clean up functionscleanup() {
    rm -f "$TEMP_FILE"
    echo "Cleaning Completed"
}

# Save progresssave_progress() {
    echo "Save the current progress to $LOG_FILE"
    echo "Progress saved at $(date)" >> "$LOG_FILE"
}

# Set up multiple signal processingtrap on_interrupt SIGINT
trap on_terminate SIGTERM
trap on_exit EXIT

# Main Programecho "Start the data..."
while true; do
    echo "Processing..."
    sleep 1
done

#!/bin/bash

critical_operation() {
    # Temporarily disable Ctrl+C    trap '' SIGINT
    
    echo "Perform a critical operation, pressing Ctrl+C during this period is invalid..."
    sleep 5
    
    # Recover signal processing    trap on_interrupt SIGINT
    echo "Critical operation is completed, normal signal processing is restored"
}

on_interrupt() {
    echo -e "\nThe operation was interrupted!"
    exit 1
}

trap on_interrupt SIGINT

echo "Start execution..."
critical_operation
echo "Continue other operations..."

#!/bin/bash

# Used to control whether the DEBUG trap is triggered in the error handling functionIN_ERROR_HANDLER=0

# Define debug processing functionson_debug() {
    # If in the error handling function, skip debug output    if ((IN_ERROR_HANDLER)); then
        return
    fi
    # $1 is the line number, $BASH_COMMAND is the command to be executed    echo "[DEBUG] Line $1: Prepare to execute -> $BASH_COMMAND"
}

# Error handling functionon_error() {
    local err=$?  # Save the error code immediately    local line=$1
    local cmd=$2
    
    # Set flags to prevent DEBUG trap from triggering in error handling    IN_ERROR_HANDLER=1
    
    echo "[ERROR] line $line failed to execute"
    echo "Command: $cmd"
    echo "Error code: $err"
    
    # Reset flag    IN_ERROR_HANDLER=0
}

# Enable debug trackingenable_debug() {
    # Enable ERR trap    set -E
    # -T option can display function call trace    set -T
    # Set DEBUG trap and pass in line number parameters    trap 'on_debug ${LINENO}' DEBUG
    trap 'on_error ${LINENO} "$BASH_COMMAND"' ERR
}

# Turn off debug trackingdisable_debug() {
    trap - DEBUG
    trap - ERR
    set +E
    set +T
}

# Control whether to enable debugging through environment variablesif [[ "${ENABLE_DEBUG}" == "true" ]]; then
    enable_debug
fi

# Test functiontest_function() {
    echo "Execute test function"
    local result=$((2 + 2))
    echo "Calculation result: $result"
    # Deliberately create an error    ls /nonexistent_directory
}

# Main Programecho "Start execution..."
test_function
echo "Try to access a file that does not exist..."
cat nonexistent_file.txt

# Normal execution./

# Turn on debug mode executionENABLE_DEBUG=true ./

#!/bin/bash

LOCK_FILE="/tmp/"
PID_FILE="/tmp/"

cleanup() {
    rm -f "$LOCK_FILE" "$PID_FILE"
    echo "Clean lock files and PID files"
}

get_lock() {
    if [ -e "$LOCK_FILE" ]; then
        local pid
        pid=$(cat "$PID_FILE" 2>/dev/null)
        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
            echo "Another example(PID: $pid)Running"
            exit 1
        fi
        # If the process does not exist, clean up the old lock        cleanup
    fi
    
    echo $$ > "$PID_FILE"
    touch "$LOCK_FILE"
    trap cleanup EXIT
}

#!/bin/bash

LOCK_FILE="/tmp/"

(
    # Get the file lock and wait for up to 5 seconds    flock -w 5 200 || { echo "Cannot acquire lock, another instance is running"; exit 1; }
    
    echo "Get the lock, start executing..."
    sleep 10
    echo "Execution Completed"
    
) 200>"$LOCK_FILE"

#!/bin/bash

# Status variablesTRANSACTION_ACTIVE=false

# Dynamically change signal processingupdate_signal_handler() {
    if $TRANSACTION_ACTIVE; then
        # Transaction is in progress, set interrupt processing to prompt and end        trap 'echo "The transaction is in progress and has been forcibly interrupted..."; cleanup; exit 1' SIGINT
    else
        # Non-transaction state, can exit safely        trap 'echo "Exit normally..."; exit 0' SIGINT
    fi
}

# Clean up functionscleanup() {
    echo "Perform a cleanup operation..."
    # Add the actual cleaning code here}

# Simulate transactionsstart_transaction() {
    TRANSACTION_ACTIVE=true
    update_signal_handler
    echo "Transaction Begins"
    
    # Simulate transaction operations    echo "Execute transaction steps 1/3"
    sleep 2
    echo "Execute transaction step 2/3"
    sleep 2
    echo "Execute transaction step 3/3"
    sleep 2
    
    TRANSACTION_ACTIVE=false
    update_signal_handler
    echo "Transaction Completed"
}

# Set initial signal processingupdate_signal_handler

# Main program execution processecho "Start execution..."
start_transaction
echo "Continue other operations..."