Backup Script With Rsync

rsync -a "$source_dir" "$staging_dir"

create_backup() {
    ...
    # stage first
    log_info "Staging before committing..."
    staging_rysnc_output=$(rsync -a "$source_dir" "$staging_dir" 2>&1)
    staging_rysnc_status=$?

    # exit if staging failed
    if [[ "$staging_rysnc_status" -ne 0 ]]; then
        log_warn "$staging_rysnc_output"
        log_fatal "Failed to sync files from $source to staging area, could be permission issues."
        notify "FAILURE" "Sync failed for $source_dir"
        rm -rf "$destination" # cleanup
        exit "$EXIT_CP_FAILED"
    fi 

    log_info "Synced files to staging area: $staging_dir"
    ...
}

create_backup() {
    ...
    destination_dirname=$(dirname $destination)
    previous_backup=""
    # gt 1 because shouldn't count current timestamped backup dir ready to backup
    if [[ "$(ls $destination_dirname | wc -l)" -gt 1 ]]; then
        # normally tail -n 1 should get but we have fresh timestamped dir also, so tail -n 2 | head -n 1
        previous_backup=$(find "$destination_dirname" -maxdepth 1 -type d 2>/dev/null | sort | tail -n 2 | head -n 1)
    fi

    rsync_args=(-a)
    if [[ -n "$previous_backup" ]]; then
        rsync_args+=(--link-dest="$previous_backup")
        log_info "Using previous backup for incremental sync: $previous_backup"
    fi

    staging_rysnc_output=$(rsync ${rsync_args[@]} "$source_dir" "$staging_dir" 2>&1)
    staging_rysnc_status=$?

    # exit if staging failed
    ...

#!/usr/bin/env bash

set -euo pipefail

# ---------------------------
# Usage and Log Functions
# ---------------------------
usage() {
    cat << 'EOF'
Usage: backup.sh -s SOURCE [-b BACKUP_ROOT] [-n] [-h] [-v]

  -s SOURCE         Source directory to back up
  -b BACKUP_ROOT    Root directory to store backups in (Default: $HOME/backup)
  -n, --dry-run     Show what would happen without making changes
  -h, --help        Show this help message and exit
  -v, --version     Show version information and exit
EOF
}

# reusable log function
log() {
    local level="$1"
    shift
    local ts
    ts=$(date '+%Y-%m-%d %H:%M:%S')
    printf "[$ts] [$level] $*\n" >&2
}

# log function by type which uses log() under the hood, takes log message as argument
log_info()  { log "INFO"  "$@"; }
log_warn()  { log "WARN"  "$@"; }
log_error() { log "ERROR" "$@"; }
log_fatal() { log "FATAL" "$@"; }

get_value() {
    if [[ $# -lt 2 ]]; then
        echo "Option -s requires an argument" >&2
        usage >&2
        exit "$EXIT_MISSING_ARGS"
    fi
    # return value 
    echo "$2"
}

# ---------------------------
# Readonly vars
# ---------------------------

# define exit codes 
readonly EXIT_BACKUP_FAILED=1
readonly EXIT_CP_FAILED=1 # treat as script/backup failure
readonly EXIT_SOURCE_MISSING=2
readonly EXIT_MKDIR_FAILED=3
readonly EXIT_ALREADY_RUNNING=4
readonly EXIT_INVALID_PATH=5
readonly EXIT_MISSING_ARGS=6

# ---------------------------
# Argument Parsing
# ---------------------------

dry_run=false
source_dir=""
backup_root=""

if [[ $# -lt 1 ]]; then
    usage
    exit 0
fi

while [[ $# -gt 0 ]]; do
    case "$1" in
        -s)
            source_dir="$(get_value $@)"
            shift 2
            ;;

        -b)
            backup_root="$(get_value $@)"
            shift 2
            ;;

        -n|--dry-run)
            dry_run=true
            shift
            ;;

        -h|--help)
            usage
            exit 0
            ;;

        -v|--version)
            echo "backup.sh 4.0.0"
            exit 0
            ;;

        *)
            echo "Invalid argument: $1"
            usage
            exit "$EXIT_MISSING_ARGS"
            ;;
    esac
done

# ---------------------------
# Constants
# ---------------------------
SOURCE="$source_dir"
backup_root="${backup_root%/}" # remove trailing slash
BACKUP_ROOT="${backup_root:-$HOME/backup}"

# ---------------------------
# User Defined Functions
# ---------------------------

cleanup() {
    set +u # staging_dir may not be avl if exit by trying ro run concurrently
    rm -f "$lock_file"
    rm -rf "$staging_dir"
}
trap cleanup EXIT

# notify 
notify() {
    local status="$1"
    local message="$2"
    log_info "NOTIFY [$status]: $message"
}

# check if dir exists, takes 1st arg as dir name
dir_exists() {
    local dir_name="$1"
    [[ -d "$dir_name" ]] && return 0
}

# create dir (including missing parent), 1st arg is dir name
make_dir() {
    local dir_name="$1"
    mkdir -p "$dir_name" || return 1
}

# print check msg for dir, 1st arg is dir name, 2nd arg is identifier of dir
print_dir_check_msg_for () {
    local dir_name="$1"
    local dir_identifier="$2"
    log_info "Checking $dir_identifier directory: '$dir_name'"
}

# create dir only if it doesn't exists, takes 1st arg is dir name, 2nd arg is dir identifier to print 
create_dir_if_not_exists() {
    local dir_name="$1"
    local dir_identifier="$2"
    print_dir_check_msg_for "$dir_name" "$dir_identifier"
    if ! dir_exists "$dir_name"; then
        log_warn "Directory doesn't exists: '$dir_name', Creating..."
        if ! make_dir "$dir_name"; then
            log_error "Creating directory failed: '$dir_name'"
            return 1
        else
            log_info "Directory created successfully: '$dir_name'"
        fi
    fi
}

# create backup, takes 1st arg as source dir, 2nd as staging_dir (temp). 3rd as destination to backup 
create_backup() {
    local source="$1"
    local staging_dir="$2"
    local destination="$3"
    log_info "Backup process start: '$source' to '$destination'"

    # stage first
    log_info "Staging before committing..."

    destination_dirname=$(dirname $destination)
    previous_backup=""
    # gt 1 because shouldn't count current timestamped backup dir ready to backup  
    if [[ "$(ls $destination_dirname | wc -l)" -gt 1 ]]; then
    # normally tail -n 1 should get but we have fresh timestamped dir also, so tail -n 2 | head -n 1
        previous_backup=$(find "$destination_dirname" -maxdepth 1 -type d 2>/dev/null | sort | tail -n 2 | head -n 1)
    fi

    rsync_args=(-a)
    if [[ -n "$previous_backup" ]]; then
        rsync_args+=(--link-dest="$previous_backup")
        log_info "Using previous backup for incremental sync: $previous_backup"
    fi

    staging_rysnc_output=$(rsync ${rsync_args[@]} "$source_dir/" "$staging_dir/" 2>&1)
    staging_rysnc_status=$?

    # exit if staging failed
    if [[ "$staging_rysnc_status" -ne 0 ]]; then
        log_warn "$staging_rysnc_output"
        log_fatal "Failed to sync files from $source to staging area, could be permission issues."
        notify "FAILURE" "Sync failed for $source_dir"
        rm -rf "$destination" # cleanup
        exit "$EXIT_CP_FAILED"
    fi 

    log_info "Synced files to staging area: $staging_dir"

    log_info "Committing staged changes..."
    if [[ "$dry_run" == true ]]; then
        log_info "[DRY RUN] Would move $staging_dir to $destination"
        rm -rf "$destination" # cleanup
        mv_status=0 # delibarately set status true
        mv_output=""
    else
        shopt -s dotglob
        mv_output=$(mv $staging_dir/* "$destination" 2>&1)
        mv_status=$?
        shopt -u dotglob
    fi

    if [[ "$mv_status" -ne 0 ]]; then
        log_warn "$mv_output"
        log_error "Failed to move staged backup into place: $destination"
        notify "FAILURE" "Move to destination failed: $destination"
        return 1
    fi
    printf "Backup success: '$source' to '$destination'\n"
    notify "SUCCESS" "Backup complete: $destination"
}

# just print section end, no args required
print_section_end() {
    printf "\n"
}

# create lock file
set_lock () {
    local lock_file="/tmp/backup-script.lock"
    if [[ -f "$lock_file" ]]; then
        existing_pid=$(cat "$lock_file")
        if kill -0 "$existing_pid" 2>/dev/null; then
            log_fatal "Backup already running as PID $existing_pid"
            return 1
        else
            log_warn "Removing stale lock file: (PID $existing_pid no longer running)"
            rm -f "$lock_file"
        fi
    fi
    echo "$$" > "$lock_file"
    log_info "Lock set: (PID $$)"
    printf "$lock_file"
}

# validate dangerous paths, 1st arg path, 2nd arg path identifier
validate_path() {
    local path="$1"
    local path_identifier="$2"
    if [[ -z "$path" || "$path" == "/" ]]; then
        log_fatal "Refusing to operate on dangerous path for $path_identifier: '$path'"
        return 1
    fi
}

# ---------------------------
# Driver Code
# ---------------------------

# set lock first
lock_file=$(set_lock) || exit "$EXIT_ALREADY_RUNNING"

# validate before starting
validate_path "$SOURCE" "source dir" || exit "$EXIT_INVALID_PATH"
validate_path "$BACKUP_ROOT" "backup root" || exit "$EXIT_INVALID_PATH"

# exit if source doesn't exists 
if ! dir_exists "$SOURCE"; then
    log_fatal "Source directory doesn't exists: '$SOURCE', Exiting..."
    exit "$EXIT_SOURCE_MISSING"
fi

# create if backup root does not exists, exit if creation failed 
create_dir_if_not_exists "$BACKUP_ROOT" "backup root" || (log_fatal "Backup root creation failed, Exiting..." && exit "$EXIT_MKDIR_FAILED")
print_section_end

# create destination, exit if failed
timestamp=$(date +%Y%m%d_%H%M%S)
source_abs_path=$(realpath $SOURCE)
destination="$BACKUP_ROOT/$source_abs_path/$timestamp"
create_dir_if_not_exists "$destination" "destination" || (log_fatal "Creating backup destination failed, Exiting..." && exit "$EXIT_MKDIR_FAILED")
print_section_end

# create backup, exit if failed (script failure exit 1)
staging_dir=$(mktemp -d)
create_backup "$source_abs_path" "$staging_dir" "$destination" || (printf "Backup failed: partial or full, Exiting...\n" && exit "$EXIT_BACKUP_FAILED")

mkdir -p /tmp/shell-course-demo/source_dir
touch /tmp/shell-course-demo/source_dir/file1.txt
mkdir -p /tmp/shell-course-demo/dest_broken

rsync -a /tmp/shell-course-demo/source_dir /tmp/shell-course-demo/dest_broken
ls /tmp/shell-course-demo/dest_broken

mkdir -p /tmp/shell-course-demo/dest_fixed
rsync -a /tmp/shell-course-demo/source_dir/ /tmp/shell-course-demo/dest_fixed
ls /tmp/shell-course-demo/dest_fixed

/backup.sh -s database_project/ -b /tmp/temp/