A maintenance script

Open every script with set -euo pipefail. This one line changes bash from permissive to strict:

• -e — exit immediately if any command returns a non-zero status (unless it’s part of if, ||, &&, or a while condition).
• -u — treat unset variables as errors instead of silently expanding to empty. rm -rf "$MISSING_VAR/data" expands to rm -rf "/data" without -u; with it, bash exits before running the command.
• -o pipefail — without this, a pipeline like broken_command | tee output.log returns 0 if tee succeeds, hiding the failure. With pipefail, the pipeline’s exit code is the rightmost non-zero status.

#!/usr/bin/env bash
set -euo pipefail

Put this on line 2 of every script that runs unattended. The shebang #!/usr/bin/env bash is preferred over #!/bin/bash because it finds the bash from PATH, which matters on systems where bash lives outside /bin.

Register a trap on EXIT for guaranteed cleanup. trap COMMAND SIGNAL runs COMMAND when the script receives SIGNAL. EXIT is special — it fires on every exit: normal completion, exit N, error exit from -e, and even SIGTERM. This makes trap cleanup EXIT the correct pattern for cleanup logic.

TMPDIR_WORK=""

cleanup() {
  if [[ -n "$TMPDIR_WORK" && -d "$TMPDIR_WORK" ]]; then
    rm -rf "$TMPDIR_WORK"
    echo "[cleanup] removed $TMPDIR_WORK" >&2
  fi
}
trap cleanup EXIT

Order matters: register the trap before creating the resource. If the script fails between mktemp and trap, cleanup never runs. Always trap first, then allocate.

TMPDIR_WORK=$(mktemp -d)   # safe: trap already registered

Handle arguments with validation. A script that silently ignores a missing argument or operates on the wrong path is dangerous. Check $# (argument count) early and print a usage line to stderr.

usage() {
  echo "Usage: $0 <src_dir> <backup_dir> [keep_days]" >&2
  exit 1
}

[[ $# -lt 2 ]] && usage

SRC="${1:?source directory required}"
DEST="${2:?backup directory required}"
KEEP="${3:-7}"  # default: keep 7 days of backups

${VAR:?message} is a parameter expansion that exits with an error message if VAR is empty or unset — a tighter check than a manual [[ -z ]] guard. ${VAR:-default} supplies a fallback without failing.

Always quote every variable that holds a path: "$SRC", "$DEST". Unquoted paths with spaces in them split into multiple arguments — the most common cause of “works on my laptop” failures.

Write the backup function. A function keeps the logic readable and lets you test it independently. Name functions as verbs.

do_backup() {
  local src="$1"
  local dest="$2"
  local ts
  ts=$(date +%Y%m%d_%H%M%S)
  local target="${dest}/backup_${ts}"

  echo "[backup] copying ${src} → ${target}" >&2
  cp -a "${src}/." "${target}"
  echo "[backup] done: ${target}" >&2
}

local prevents variables from leaking into the global scope. cp -a (archive mode) preserves permissions, timestamps, and symlinks — the correct choice for a backup. cp -a "${src}/." "${target}" copies the contents of src into target (the trailing /. trick); using "${src}" without the slash copies the directory itself, which creates an extra nesting level.

Rotate old backups with find -mtime. -mtime +N matches files modified more than N×24 hours ago. -maxdepth 1 prevents recursion into subdirectories, which is critical when dest contains the current backup you just wrote.

rotate_backups() {
  local dest="$1"
  local keep="$2"
  echo "[rotate] removing backups older than ${keep} days in ${dest}" >&2
  find "${dest}" -maxdepth 1 -name 'backup_*' -type d -mtime "+${keep}" \
    -exec rm -rf {} +
}

-exec rm -rf {} + batches all matches into one rm call (more efficient than -exec ... \; which spawns a process per match). The pattern backup_* protects against accidentally deleting unrelated directories in dest.