Bash Scripting: Practical Patterns for Systems Work

# Always quote variable expansions
NAME="Valeriy"
echo "Hello, ${NAME}!"       # prefer ${} syntax for clarity

# Default values
LOG_DIR="${LOG_DIR:-/var/log/app}"    # use default if unset or empty
PORT="${PORT:=8080}"                   # assign default if unset

# Read-only constants
readonly MAX_RETRIES=3
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Command substitution
CURRENT_DATE=$(date +%Y%m%d)
HOSTNAME=$(hostname -f)
RUNNING_PROCS=$(ps aux | wc -l)

# Indexed arrays
SERVERS=("web01" "web02" "web03" "db01")

echo "${SERVERS[0]}"           # first element
echo "${SERVERS[@]}"           # all elements
echo "${#SERVERS[@]}"          # array length
echo "${SERVERS[@]:1:2}"       # slice: elements 1 and 2

# Append to array
SERVERS+=("cache01")

# Iterate
for server in "${SERVERS[@]}"; do
    echo "Checking ${server}..."
done

# Associative arrays (Bash 4+)
declare -A CONFIG
CONFIG[db_host]="db.internal"
CONFIG[db_port]="5432"
CONFIG[db_name]="appdb"

echo "${CONFIG[db_host]}"
for key in "${!CONFIG[@]}"; do
    echo "${key} = ${CONFIG[$key]}"
done

STR="Hello, World!"

echo "${#STR}"                 # length: 13
echo "${STR,,}"                # lowercase: hello, world!
echo "${STR^^}"                # uppercase: HELLO, WORLD!

# Substrings
echo "${STR:0:5}"              # Hello
echo "${STR: -6}"              # World!

# Pattern removal
FILE="archive-2024-01-15.tar.gz"
echo "${FILE%.tar.gz}"         # strip shortest suffix: archive-2024-01-15
echo "${FILE%%.*}"             # strip longest suffix:  archive-2024-01-15
echo "${FILE#archive-}"        # strip prefix: 2024-01-15.tar.gz

# Substitution
URL="http://old-host.example.com/path"
echo "${URL/old-host/new-host}"          # replace first match
echo "${URL//example/EXAMPLE}"           # replace all matches

# Iterate over a list
for env in dev staging production; do
    echo "Deploying to ${env}..."
done

# Iterate over array
for server in "${SERVERS[@]}"; do
    ssh "${server}" "sudo systemctl restart app"
done

# C-style numeric loop
for (( i=1; i<=10; i++ )); do
    echo "Attempt ${i}"
done

# Iterate over files
for conf in /etc/app/*.conf; do
    [[ -f "${conf}" ]] || continue    # skip if glob matched nothing
    echo "Processing ${conf}"
done

# Iterate over command output lines
while IFS= read -r line; do
    echo "Processing: ${line}"
done < <(find /var/data -name "*.json" -mtime -1)

# Poll until a service is ready
RETRIES=0
MAX_RETRIES=12
until curl -sf http://localhost:8080/health; do
    (( RETRIES++ ))
    if (( RETRIES >= MAX_RETRIES )); then
        echo "Service did not start after ${MAX_RETRIES} attempts" >&2
        exit 1
    fi
    echo "Waiting for service... (${RETRIES}/${MAX_RETRIES})"
    sleep 5
done

# Process lines from a file
while IFS= read -r -u 3 line; do
    [[ "${line}" =~ ^# ]] && continue    # skip comments
    [[ -z "${line}" ]]    && continue    # skip empty lines
    echo "Server: ${line}"
done 3< servers.txt

for i in {1..100}; do
    (( i % 10 == 0 )) && echo "Checkpoint: ${i}"
    (( i == 50 )) && break        # exit loop
    (( i % 2 == 0 )) && continue  # skip even numbers
    echo "${i}"
done

# Define before calling
log() {
    local level="${1}"
    local message="${2}"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [${level}] ${message}" | tee -a "${LOG_FILE:-/tmp/script.log}"
}

die() {
    log "ERROR" "${1}"
    exit "${2:-1}"
}

# Call
log "INFO" "Starting deployment"
die "Config file not found" 2

# Functions return exit codes, not values
# Use local to avoid polluting global scope
get_free_memory_mb() {
    local free_mb
    free_mb=$(free -m | awk '/^Mem:/{print $7}')
    echo "${free_mb}"    # "return" a value via stdout
}

# Capture output
FREE=$(get_free_memory_mb)
echo "Available memory: ${FREE} MB"

# Return codes
is_service_running() {
    local service_name="${1}"
    systemctl is-active --quiet "${service_name}"
    # returns 0 if active, non-zero otherwise
}

if is_service_running "nginx"; then
    echo "nginx is up"
fi

require_root() {
    if (( EUID != 0 )); then
        die "This script must be run as root" 1
    fi
}

require_command() {
    local cmd="${1}"
    if ! command -v "${cmd}" &>/dev/null; then
        die "Required command not found: ${cmd}" 127
    fi
}

retry() {
    local attempts="${1}"; shift
    local delay="${1}";    shift
    local n=0

    until "$@"; do
        (( n++ ))
        if (( n >= attempts )); then
            echo "Command failed after ${attempts} attempts: $*" >&2
            return 1
        fi
        echo "Attempt ${n} failed. Retrying in ${delay}s..."
        sleep "${delay}"
    done
}

# Usage
retry 3 5 curl -sf http://api.example.com/health

# Always-run cleanup on exit
TMPDIR_WORK=$(mktemp -d)
cleanup() {
    rm -rf "${TMPDIR_WORK}"
    log "INFO" "Cleanup complete"
}
trap cleanup EXIT

# Handle interrupts gracefully
trap 'log "WARN" "Caught SIGINT — aborting"; exit 130' INT
trap 'log "WARN" "Caught SIGTERM — aborting"; exit 143' TERM

# Debug trap — print each command before executing (useful during dev)
# trap 'echo "DEBUG: line ${LINENO}: ${BASH_COMMAND}"' DEBUG

# Standard POSIX exit codes
# 0    success
# 1    general error
# 2    misuse of shell built-in
# 126  command found but not executable
# 127  command not found
# 128+N  fatal signal N (e.g., 130 = SIGINT, 143 = SIGTERM)

# Propagate exit codes explicitly
deploy_app() {
    local exit_code=0

    rsync -az /opt/release/ app@web01:/opt/app/ || exit_code=$?
    if (( exit_code != 0 )); then
        log "ERROR" "rsync failed with exit code ${exit_code}"
        return "${exit_code}"
    fi

    ssh app@web01 "sudo systemctl restart app" || exit_code=$?
    return "${exit_code}"
}

# Some commands legitimately return non-zero
# Use || true to allow failure
grep "pattern" file.txt || true

# Or use an explicit check
if ! grep -q "pattern" file.txt; then
    echo "Pattern not found — continuing"
fi

# Subshell failures with set -e
(
    cd /some/dir
    run_something
) || die "Subshell block failed"