#!/usr/bin/env bash # snap-sync # https://github.com/wesbarnett/snap-sync # Copyright (C) 2016-2021 Wes Barnett # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # You should have received a copy of the GNU General Public License along # with this program; if not, write to the Free Software Foundation, Inc., # ------------------------------------------------------------------------- # Takes snapshots of each snapper configuration. It then sends the snapshot to # a location on an external drive. After the initial transfer, it does # incremental snapshots on later calls. It's important not to delete the # snapshot created on your system since that will be used to determine the # difference for the next incremental snapshot. set -o errtrace version="0.7" name="snap-sync" printf "\nsnap-sync version %s, Copyright (C) 2016-2021 Wes Barnett\n" "$version" printf "snap-sync comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under certain conditions. See the license for more information. \n\n" # The following line is modified by the Makefile or # find_snapper_config script SNAPPER_CONFIG=/etc/sysconfig/snapper donotify=0 if ! command -v notify-send &> /dev/null; then donotify=1 fi doprogress=0 if ! command -v pv &> /dev/null; then doprogress=1 fi error() { printf "==> ERROR: %s\n" "$@" notify_error 'Error' 'Check journal for more information.' } >&2 die() { error "$@" exit 1 } traperror() { printf "Exited due to error on line %s.\n" "$1" printf "exit status: %s\n" "$2" printf "command: %s\n" "$3" printf "bash line: %s\n" "$4" printf "function name: %s\n" "$5" exit 1 } trapkill() { die "Exited due to user intervention." } trap 'traperror ${LINENO} $? "$BASH_COMMAND" $BASH_LINENO "${FUNCNAME[@]}"' ERR trap trapkill SIGTERM SIGINT usage() { cat <<EOF $name $version Usage: $name [options] Options: -c, --config <config> snapper configuration to backup -d, --description <desc> snapper description -h, --help print this message -n, --noconfirm do not ask for confirmation -k, --keepold keep old incremental snapshots instead of deleting them after backup is performed -p, --port <port> remote port; used with '--remote'. -q, --quiet do not send notifications; instead print them. -r, --remote <address> ip address of a remote machine to backup to --sudo use sudo on the remote machine -s, --subvolid <subvlid> subvolume id of the mounted BTRFS subvolume to back up to -u, --UUID <UUID> UUID of the mounted BTRFS subvolume to back up to See 'man snap-sync' for more details. EOF } ssh="" sudo=0 while [[ $# -gt 0 ]]; do key="$1" case $key in -d|--description) description="$2" shift 2 ;; -c|--config) selected_configs="$2" shift 2 ;; -u|--UUID) uuid_cmdline="$2" shift 2 ;; -s|--subvolid) subvolid_cmdline="$2" shift 2 ;; -k|--keepold) keep="yes" shift ;; -n|--noconfirm) noconfirm="yes" shift ;; -h|--help) usage exit 1 ;; -q|--quiet) donotify=1 shift ;; -r|--remote) remote=$2 shift 2 ;; -p|--port) port=$2 shift 2 ;; --sudo) sudo=1 shift ;; *) die "Unknown option: '$key'. Run '$name -h' for valid options." ;; esac done notify() { for u in $(users | tr ' ' '\n' | sort -u); do sudo -u "$u" DISPLAY=:0 \ DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/$(sudo -u "$u" id -u)/bus" \ notify-send -a $name "$1" "$2" --icon="dialog-$3" done } notify_info() { if [[ $donotify -eq 0 ]]; then notify "$1" "$2" "information" else printf '%s\n' "$1: $2" fi } notify_error() { if [[ $donotify -eq 0 ]]; then notify "$1" "$2" "error" else printf '%s\n' "$1: $2" fi } [[ $EUID -ne 0 ]] && die "Script must be run as root. See '$name -h' for a description of options" ! [[ -f $SNAPPER_CONFIG ]] && die "$SNAPPER_CONFIG does not exist." description=${description:-"latest incremental backup"} uuid_cmdline=${uuid_cmdline:-"none"} subvolid_cmdline=${subvolid_cmdline:-"5"} noconfirm=${noconfirm:-"no"} if [[ -z $remote ]]; then if ! command -v rsync &> /dev/null; then die "--remote specified but rsync command not found" fi fi if [[ "$uuid_cmdline" != "none" ]]; then if [[ -z $remote ]]; then notify_info "Backup started" "Starting backups to $uuid_cmdline subvolid=$subvolid_cmdline..." else notify_info "Backup started" "Starting backups to $uuid_cmdline subvolid $subvolid_cmdline at $remote..." fi else if [[ -z $remote ]]; then notify_info "Backup started" "Starting backups. Use command line menu to select disk." else notify_info "Backup started" "Starting backups. Use command line menu to select disk on $remote." fi fi if [[ -n $remote ]]; then ssh="ssh $remote" if [[ -n $port ]]; then ssh="$ssh -p $port" fi if [[ $sudo -eq 1 ]]; then ssh="$ssh sudo" fi fi if [[ "$($ssh findmnt -n -v --target / -o FSTYPE)" == "btrfs" ]]; then EXCLUDE_UUID=$($ssh findmnt -n -v -t btrfs --target / -o UUID) TARGETS=$($ssh findmnt -n -v -t btrfs -o UUID,TARGET --list | grep -v "$EXCLUDE_UUID" | awk '{print $2}') UUIDS=$($ssh findmnt -n -v -t btrfs -o UUID,TARGET --list | grep -v "$EXCLUDE_UUID" | awk '{print $1}') else TARGETS=$($ssh findmnt -n -v -t btrfs -o TARGET --list) UUIDS=$($ssh findmnt -n -v -t btrfs -o UUID --list) fi declare -a TARGETS_ARRAY declare -a UUIDS_ARRAY declare -a SUBVOLIDS_ARRAY i=0 for x in $TARGETS; do SUBVOLIDS_ARRAY[$i]=$($ssh btrfs subvolume show "$x" | awk '/Subvolume ID:/ { print $3 }') TARGETS_ARRAY[$i]=$x i=$((i+1)) done i=0 disk=-1 disk_count=0 for x in $UUIDS; do UUIDS_ARRAY[$i]=$x if [[ "$x" == "$uuid_cmdline" && ${SUBVOLIDS_ARRAY[$((i))]} == "$subvolid_cmdline" ]]; then disk=$i disk_count=$((disk_count+1)) fi i=$((i+1)) done if [[ "${#UUIDS_ARRAY[$@]}" -eq 0 ]]; then die "No external btrfs subvolumes found to backup to. Run '$name -h' for more options." fi if [[ "$disk_count" -gt 1 ]]; then printf "Multiple mount points were found with UUID %s and subvolid %s.\n" "$uuid_cmdline" "$subvolid_cmdline" disk="-1" fi if [[ "$disk" == -1 ]]; then if [[ "$disk_count" == 0 && "$uuid_cmdline" != "none" ]]; then error "A device with UUID $uuid_cmdline and subvolid $subvolid_cmdline was not found to be mounted, or it is not a BTRFS device." fi if [[ -z $ssh ]]; then printf "Select a mounted BTRFS device on your local machine to backup to.\nFor more options, exit and run '%s -h'.\n" "$name" else printf "Select a mounted BTRFS device on %s to backup to.\nFor more options, exit and run '%s -h'.\n" "$remote" "$name" fi while [[ $disk -lt 0 || $disk -gt $i ]]; do for x in "${!TARGETS_ARRAY[@]}"; do printf "%4s) %s (uuid=%s, subvolid=%s)\n" "$((x+1))" "${TARGETS_ARRAY[$x]}" "${UUIDS_ARRAY[$x]}" "${SUBVOLIDS_ARRAY[$x]}" done printf "%4s) Exit\n" "0" read -e -r -p "Enter a number: " disk if ! [[ $disk == ?(-)+([0-9]) ]] || [[ $disk -lt 0 || $disk -gt $i ]]; then printf "\nNo disk selected. Select a disk to continue.\n" disk=-1 fi done if [[ $disk == 0 ]]; then exit 0 fi disk=$((disk-1)) fi selected_subvolid="${SUBVOLIDS_ARRAY[$((disk))]}" selected_uuid="${UUIDS_ARRAY[$((disk))]}" selected_mnt="${TARGETS_ARRAY[$((disk))]}" printf "\nYou selected the disk with uuid=%s, subvolid=%s.\n" "$selected_uuid" "$selected_subvolid" if [[ -z $ssh ]]; then printf "The disk is mounted at '%s'.\n" "$selected_mnt" else printf "The disk is mounted at '%s:%s'.\n" "$remote" "$selected_mnt" fi # shellcheck source=/etc/default/snapper source "$SNAPPER_CONFIG" if [[ -z $selected_configs ]]; then printf "\nInteractively cycling through all snapper configurations...\n" fi selected_configs=${selected_configs:-$SNAPPER_CONFIGS} declare -a BACKUPDIRS_ARRAY declare -a MYBACKUPDIR_ARRAY declare -a OLD_NUM_ARRAY declare -a OLD_SNAP_ARRAY declare -a NEW_NUM_ARRAY declare -a NEW_SNAP_ARRAY declare -a NEW_INFO_ARRAY declare -a BACKUPLOC_ARRAY declare -a CONT_BACKUP_ARRAY # Initial configuration of where backup directories are i=0 for x in $selected_configs; do if [[ "$(snapper -c "$x" list --disable-used-space -t single | awk '/'"subvolid=$selected_subvolid, uuid=$selected_uuid"'/ {cnt++} END {print cnt}')" -gt 1 ]]; then error "More than one snapper entry found with UUID $selected_uuid subvolid $selected_subvolid for configuration $x. Skipping configuration $x." continue fi if [[ "$(snapper -c "$x" list --disable-used-space -t single | awk '/'$name' backup in progress/ {cnt++} END {print cnt}')" -gt 0 ]]; then printf "\nNOTE: Previous failed %s backup snapshots found for '%s'.\n" "$name" "$x" if [[ $noconfirm == "yes" ]]; then printf "'noconfirm' option passed. Failed backups will not be deleted.\n" else read -e -r -p "Delete failed backup snapshot(s)? (These local snapshots from failed backups are not used.) [y/N]? " delete_failed while [[ -n "$delete_failed" && "$delete_failed" != [Yy]"es" && "$delete_failed" != [Yy] && "$delete_failed" != [Nn]"o" && "$delete_failed" != [Nn] ]]; do read -e -r -p "Delete failed backup snapshot(s)? (These local snapshots from failed backups are not used.) [y/N] " delete_failed if [[ -n "$delete_failed" && "$delete_failed" != [Yy]"es" && "$delete_failed" != [Yy] && "$delete_failed" != [Nn]"o" && "$delete_failed" != [Nn] ]]; then printf "Select 'y' or 'N'.\n" fi done if [[ "$delete_failed" == [Yy]"es" || "$delete_failed" == [Yy] ]]; then # explicit split list of snapshots (on whitespace) into multiple arguments # shellcheck disable=SC2046 snapper -c "$x" delete $(snapper -c "$x" list --disable-used-space | awk '/'$name' backup in progress/ {print $1}') fi fi fi SNAP_SYNC_EXCLUDE=no if [[ -f "/etc/snapper/configs/$x" ]]; then # shellcheck source=/etc/snapper/config-templates/default source "/etc/snapper/configs/$x" else die "Selected snapper configuration $x does not exist." fi if [[ $SNAP_SYNC_EXCLUDE == "yes" ]]; then continue fi printf "\n" old_num=$(snapper -c "$x" list --disable-used-space -t single | awk '/'"subvolid=$selected_subvolid, uuid=$selected_uuid"'/ {print $1}') old_snap=$SUBVOLUME/.snapshots/$old_num/snapshot OLD_NUM_ARRAY[$i]=$old_num OLD_SNAP_ARRAY[$i]=$old_snap if [[ -z "$old_num" ]]; then printf "No backups have been performed for '%s' on this disk.\n" "$x" read -e -r -p "Enter name of subvolume to store backups, relative to $selected_mnt (to be created if not existing): " mybackupdir printf "This will be the initial backup for snapper configuration '%s' to this disk. This could take awhile.\n" "$x" BACKUPDIR="$selected_mnt/$mybackupdir" $ssh test -d "$BACKUPDIR" || $ssh btrfs subvolume create "$BACKUPDIR" else mybackupdir=$(snapper -c "$x" list --disable-used-space -t single | awk -F"|" '/'"subvolid=$selected_subvolid, uuid=$selected_uuid"'/ {print $5}' | awk -F "," '/backupdir/ {print $1}' | awk -F"=" '{print $2}') BACKUPDIR="$selected_mnt/$mybackupdir" $ssh test -d "$BACKUPDIR" || die "%s is not a directory on %s.\n" "$BACKUPDIR" "$selected_uuid" fi BACKUPDIRS_ARRAY[$i]="$BACKUPDIR" MYBACKUPDIR_ARRAY[$i]="$mybackupdir" printf "Creating new local snapshot for '%s' configuration...\n" "$x" new_num=$(snapper -c "$x" create --print-number -d "$name backup in progress") new_snap=$SUBVOLUME/.snapshots/$new_num/snapshot new_info=$SUBVOLUME/.snapshots/$new_num/info.xml sync backup_location=$BACKUPDIR/$x/$new_num/ if [[ -z $ssh ]]; then printf "Will backup %s to %s\n" "$new_snap" "$backup_location/snapshot" else printf "Will backup %s to %s\n" "$new_snap" "$remote":"$backup_location/snapshot" fi if ($ssh test -d "$backup_location/snapshot") ; then printf "WARNING: Backup directory '%s' already exists. This configuration will be skipped!\n" "$backup_location/snapshot" printf "Move or delete destination directory and try backup again.\n" fi NEW_NUM_ARRAY[$i]="$new_num" NEW_SNAP_ARRAY[$i]="$new_snap" NEW_INFO_ARRAY[$i]="$new_info" BACKUPLOC_ARRAY[$i]="$backup_location" cont_backup="K" CONT_BACKUP_ARRAY[$i]="yes" if [[ $noconfirm == "yes" ]]; then cont_backup="yes" else while [[ -n "$cont_backup" && "$cont_backup" != [Yy]"es" && "$cont_backup" != [Yy] && "$cont_backup" != [Nn]"o" && "$cont_backup" != [Nn] ]]; do read -e -r -p "Proceed with backup of '$x' configuration [Y/n]? " cont_backup if [[ -n "$cont_backup" && "$cont_backup" != [Yy]"es" && "$cont_backup" != [Yy] && "$cont_backup" != [Nn]"o" && "$cont_backup" != [Nn] ]]; then printf "Select 'Y' or 'n'.\n" fi done fi if [[ "$cont_backup" != [Yy]"es" && "$cont_backup" != [Yy] && -n "$cont_backup" ]]; then CONT_BACKUP_ARRAY[$i]="no" printf "Not backing up '%s' configuration.\n" "$x" snapper -c "$x" delete "$new_num" fi i=$((i+1)) done # Actual backing up printf "\nPerforming backups...\n" i=-1 for x in $selected_configs; do i=$((i+1)) SNAP_SYNC_EXCLUDE=no if [[ -f "/etc/snapper/configs/$x" ]]; then # shellcheck source=/etc/snapper/config-templates/default source "/etc/snapper/configs/$x" else die "Selected snapper configuration $x does not exist." fi cont_backup=${CONT_BACKUP_ARRAY[$i]} if [[ $cont_backup == "no" || $SNAP_SYNC_EXCLUDE == "yes" ]]; then notify_info "Backup in progress" "NOTE: Skipping $x configuration." continue fi notify_info "Backup in progress" "Backing up $x configuration." printf "\n" old_num="${OLD_NUM_ARRAY[$i]}" old_snap="${OLD_SNAP_ARRAY[$i]}" BACKUPDIR="${BACKUPDIRS_ARRAY[$i]}" mybackupdir="${MYBACKUPDIR_ARRAY[$i]}" new_num="${NEW_NUM_ARRAY[$i]}" new_snap="${NEW_SNAP_ARRAY[$i]}" new_info="${NEW_INFO_ARRAY[$i]}" backup_location="${BACKUPLOC_ARRAY[$i]}" if ($ssh test -d "$backup_location/snapshot") ; then printf "ERROR: Backup directory '%s' already exists. Skipping backup of this configuration!\n" "$backup_location/snapshot" continue fi $ssh mkdir -p "$backup_location" if [[ -z "$old_num" ]]; then printf "Sending first snapshot for '%s' configuration...\n" "$x" if [[ $doprogress -eq 0 ]]; then btrfs send "$new_snap" | pv | $ssh btrfs receive "$backup_location" &>/dev/null else btrfs send "$new_snap" | $ssh btrfs receive "$backup_location" &>/dev/null fi else printf "Sending incremental snapshot for '%s' configuration...\n" "$x" # Sends the difference between the new snapshot and old snapshot to the # backup location. Using the -c flag instead of -p tells it that there # is an identical subvolume to the old snapshot at the receiving # location where it can get its data. This helps speed up the transfer. if [[ $doprogress -eq 0 ]]; then btrfs send -c "$old_snap" "$new_snap" | pv | $ssh btrfs receive "$backup_location" else btrfs send -c "$old_snap" "$new_snap" | $ssh btrfs receive "$backup_location" fi if [[ $keep == "yes" ]]; then printf "Modifying data for old local snapshot for '%s' configuration...\n" "$x" snapper -v -c "$x" modify -d "old snap-sync snapshot (you may remove)" -u "backupdir=,subvolid=,uuid=" -c "number" "$old_num" else printf "Deleting old snapshot for %s...\n" "$x" snapper -c "$x" delete "$old_num" fi fi if [[ -z $remote ]]; then cp "$new_info" "$backup_location" else if [[ -z $port ]]; then rsync -avzq "$new_info" "$remote":"$backup_location" else rsync -avzqe "ssh -p $port" "$new_info" "$remote":"$backup_location" fi fi # It's important not to change this userdata in the snapshots, since that's how # we find the previous one. userdata="backupdir=$mybackupdir, subvolid=$selected_subvolid, uuid=$selected_uuid" # Tag new snapshot as the latest printf "Tagging local snapshot as latest backup for '%s' configuration...\n" "$x" snapper -v -c "$x" modify -d "$description" -u "$userdata" "$new_num" printf "Backup complete for '%s' configuration.\n" "$x" done printf "\nDone!\n" if [[ "$uuid_cmdline" != "none" ]]; then notify_info "Finished" "Backups to $uuid_cmdline complete!" else notify_info "Finished" "Backups complete!" fi