msynk/msynk.sh

#!/bin/bash
# Made by Matthias Quintern
# 03/2022
# This software comes with no warranty.
# This software is licensed under the GPL3

# ABOUT
# Synchronizes files from a sender to a receiver using rsync
# The files can be encrypted before or decrypted after the transfer using the mkrypt script

# SETTINGS
# The directory that is searched for config files
CONFIG_DIR=~/.config/msynk/
# When using encrypt/decrypt, the source is en/decrypted to TMP_DIR and then rsynced to receiver from there
# Path must contain 'msynk'
TMP_DIR=/tmp/msynk/
# When using --delete, this file is used to determine the files that will be deleted
TMP_FILE=/tmp/msynk_file
# Path to the mkrypt script
mkrypt=/usr/bin/mkrypt
# Additional flags for mkrypt
mkrypt_flags=

rsync_flags=(-ruh)
# rsync_flags+=(--rsh="ssh -p 69")
# r - relative
# v - verbose
# Ut - preserve modification&access times
# u - update, skip files that are newer on the receiver
# P - show progress and keep partially transferred files
# h - human readable
# see "man rsync" for more


# UTILITY
FMT_MESSAGE="\e[1;34m%s\e[0m\n"
FMT_ERROR="\e[1;31mERROR: \e[0m%s\n"
FMT_SYNC="\e[1;32mSyncing: \e[0m%s\n"
FMT_CONFIG="\e[34m%s\e:\t\e[1;33m%s\e[0m\n"
FMT_CMD="\e[1;33mRunning: \e[0m%s\n"

# FUNCTIONS
# silence commands
quiet() { "$@" > /dev/null 2>&1; }

# check if a passed parameter is contained in file
check_path_in_args()
{
    if [ $all = 1 ]; then
        return 0
    fi
    for string in ${FILES[@]}; do
        if [[ $path == *$string* ]]; then
            return 0
        fi
    done
    return 1
}


# SYNC SENDER TO RECEIVER
sync_sender_to_receiver()
{
    # perform a dry run to see which files would be deleted
    if [[ -n $delete && -z $skip_dryrun ]]; then
        [[ $v -ge 1 ]] && printf "$FMT_MESSAGE" "Performing dryrun to generate list of files that will be deleted from $receiver..."
        echo "" > $TMP_FILE
        for path in "${filtered_paths[@]}"; do
            dest_subdir=$receiver$(basename $path)
            rsync $rsync_flags -v --dry-run --delete $path $dest_subdir | grep deleting | sed "s(deleting (${BACKUP_SUBDIR}/(" >> $TMP_FILE
        done
        # print files that will be deleted and ask if continue
        # grep deleting $TMP_FILE | sed "s(deleting (${receiver}/(" | less
        less $TMP_FILE 

        printf "$FMT_MESSAGE" "The listed files will be deleted from $receiver."
        # FMT_UPDATE="\e[1;33mUpdating:\e[0m %s\n"
        printf "Proceed?\e[34m (y/n)\e[0m: "
        read answer
        case $answer in
            y|Y)
                # printf "$FMT_MESSAGE" "Backing up to $receiver..."
                ;;
            *)
                printf "$FMT_MESSAGE" "Cancelled."
                exit 0 ;;
        esac
    fi

    # actual syncing
    for path in "${filtered_paths[@]}"; do
        [[ $v -ge 1 ]] && printf "$FMT_SYNC" "$path"
        if [[ -d $path ]]; then
            dest=$receiver$(basename $path)
        elif [[ -f $path ]]; then
            dest=$receiver
        elif [[ $sender == *:* ]]; then  # if sender is remote, assume the path is a dir if it has a slash and a file otherwise
            [[ $path == *"/" ]] && dest=$receiver$(basename $path) || dest=$receiver
        else
            printf "$FMT_ERROR" "Invalid path: $path"; exit 1
        fi
        if [[ -n $encrypt || -n $decrypt ]]; then
            [[ -d $path ]] && tmp_source=$TMP_DIR

            if [[ -n $encrypt ]]; then
                [[ -f $path ]] && tmp_source=$TMP_DIR$(basename $path).gpg
                [[ $v -ge 3 ]] && printf "$FMT_CMD" "bash $mkrypt --encrypt $path --output $TMP_DIR $mkrypt_flags"
                bash $mkrypt --encrypt $path --output $TMP_DIR $mkrypt_flags || exit 3
                [[ $v -ge 3 ]] && printf "$FMT_CMD" "rsync ${rsync_flags[*]} $tmp_source $dest"
                rsync ${rsync_flags[*]} $tmp_source $dest || { printf "$FMT_ERROR" "rsync exited with exit code $?"; exit 2; }
            else
                [[ -f $path ]] && tmp_source=$TMP_DIR$(basename $path)
                [[ $v -ge 3 ]] && printf "$FMT_CMD" "rsync ${rsync_flags[*]} $path $TMP_DIR"
                rsync ${rsync_flags[*]} $path $TMP_DIR || { printf "$FMT_ERROR" "rsync exited with exit code $?"; exit 2; }
                [[ $v -ge 3 ]] && printf "$FMT_CMD" "bash $mkrypt --decrypt $tmp_source --output $(readlink -f $dest) $mkrypt_flags"
                bash $mkrypt --decrypt $tmp_source --output $(readlink -f $dest) $mkrypt_flags || exit 3
            fi
        else
            [[ $v -ge 3 ]] && printf "$FMT_CMD" "rsync ${rsync_flags[*]} $delete $path $dest"
            rsync ${rsync_flags[*]} $delete $path $dest || { printf "$FMT_ERROR" "rsync exited with exit code $?"; exit 2; }
        fi
        [[ $TMP_DIR == *msynk* ]] && { 
            rm -rf $TMP_DIR/* || { printf "$FMT_ERROR" "Can not delete \$TMP_DIR: $TMP_DIR"; exit 1; }
        } || { printf "$FMT_ERROR" "Will not delete \$TMP_DIR because it might be dangerous (path does not contain 'msynk'): $TMP_DIR"; exit 1; }
    done

    # put todays date in the config
    if [[ -f $CONFIG_DIR/$config ]]; then
        if grep -xq "date=.*" $CONFIG_DIR$config; then
            [[ $v -ge 2 ]] && printf "$FMT_MESSAGE" "Updating date in $CONFIG_DIR$config."
            sed "s/date=.*/date=\"$(date)\"/" $CONFIG_DIR$config -i
        else
            [[ $v -ge 2 ]] && printf "$FMT_MESSAGE" "Writing current date to $CONFIG_DIR$config."
            echo "date=\"$(date)\"" >> $CONFIG_DIR$config
        fi
    fi

    [[ $v -ge 2 ]] && printf "$FMT_MESSAGE" "Running 'sync' to write cached writes to persistent storage"
    sync
    [[ $v -ge 1 ]] && printf "$FMT_MESSAGE" "Done!"
}
    

# HELP
show_help()
{
    printf "\e[33mArgument        Short   Action:\e[0m
--help              -h      Show this.
--settings          -s      Show current settings.

--config [name]     -c      Use sender, receiver, paths from config file with [name].

--sender [path]     -s      Sender directory, with trailing slash! Defaults to the current working directory.
--receiver [path]   -r      Receiver directory, with trailing slash!.
--reverse                   Swap receiver and sender.

--encrypt                   Encrypt files before syncing.
--decrypt                   Decrypt files before syncing.
--date                      Only process files that have been modified since the program was last run. Needs -c and (--encrypt/--decrypt).
--mkrypt-flags [flags]      Additional flags for mkrypt.

--delete            -d      Delete files that exist on receiver, but not on sender. Does not work with --encrypt/--decrypt.
--skip-dryrun               Delete without asking first.
--rsync-flags [flags]       Additional flags for rsync.

--verbose           -v      Increase verbosity.
--silent                    Decrease verbosity.
--debug                     Maximum verbosity.

Positional arguments are: 
- if using a config: a string that must be in the configs paths: eg. 'foo' will include ~/foo but nor ~/bar
- if not using a config: paths to sync (must be relative to --sender)

See the manpage for more information.
"
}


# SETTINGS
show_settings()
{
    printf "\e[1mThe current settings are:\e[0m\n"
    printf "$FMT_CONFIG" "\$TMP_DIR         " "$TMP_DIR"
    printf "$FMT_CONFIG" "\$TMP_FILE        " "$TMP_FILE"
    printf "$FMT_CONFIG" "\$CONFIG_DIR      " "$CONFIG_DIR"
    [[ -f $mkrypt ]] || mkrypt_installed="(file not found)"
    printf "$FMT_CONFIG" "\$mkrypt          " "$mkrypt $mkrypt_installed"
    printf "$FMT_CONFIG" "\$rsync_flags     " "${rsync_flags[*]}"
}


# PARSE ARGS
if [ -z $1 ]; then
    show_help
    exit 0
fi

all=1
paths_2=()
while (( "$#" )); do
    case "$1" in
        -h|--help)
            show_help
            exit 0 ;;
        --settings)
            show_settings
            exit 0 ;;
        -c|--config)
            if [[ -n $2 && ${2:0:1} != "-" ]]; then
                config=$2
                shift 2
            else printf "$FMT_ERROR" "Missing argument for $1"; exit 1; fi ;;
        -s|--sender)
            if [[ -n $2 && ${2:0:1} != "-" ]]; then
                sender_2=$2
                shift 2
            else printf "$FMT_ERROR" "Missing argument for $1"; exit 1; fi ;;
        -r|--receiver)
            if [[ -n $2 && ${2:0:1} != "-" ]]; then
                receiver_2=$2
                shift 2
            else printf "$FMT_ERROR" "Missing argument for $1"; exit 1; fi ;;
        --reverse)
            reverse=1
            shift ;;
        --encrypt)
            encrypt=1
            use_encryption=1
            shift ;;
        --decrypt)
            decrypt=1
            use_encryption=1
            shift;;
        -d|--delete)
            delete=--delete
            shift ;;
        --skip-dryrun)
            skip_dryrun=1
            shift ;;
        --rsync-flags)
            if [[ -n ${2} ]]; then  # && "${2:0:1}" != "-" ]]; then  # possibly problematic if $2 is an msynk flag
                rsync_flags+=("${2}")
                shift 2
            else printf "$FMT_ERROR" "Missing argument for $1"; exit 1; fi ;;
        --date)
            use_date=1
            shift ;;
        --msynk-flags)
            if [[ -n ${2} ]]; then  # && "${2:0:1}" != "-" ]]; then  # possibly problematic if $2 is an msynk flag
                mkrypt_flags+=("${2}")
                shift 2
            else printf "$FMT_ERROR" "Missing argument for $1"; exit 1; fi ;;
        -v|--verbose)
            v=2
            rsync_flags+=(-v)
            mkrypt_flags+=(-v)
            shift ;;
        --silent)
            v=0
            mkrypt_flags+=(--silent)
            shift ;;
        --debug)
            v=3
            rsync_flags+=(-v)
            mkrypt_flags+=(-v)
            shift;;
        -*|--*=) # unsupported flags
            printf "$FMT_ERROR" "Unsupported flag $1" >&2
            exit 1 ;;
        *) # everything that does not have a - is interpreted as filepath
            all=
            paths_2+=($1)
            shift ;;
    esac
done

# PREPARATION & CHECKS
# check if rsync is installed
if ! command -v rsync &> /dev/null; then
    printf "$FMT_ERROR" "rsync is not installed."
    exit 1
fi

# if using encryption, check if mkrypt is installed
[[ $use_encryption = 1 && ! -f $mkrypt ]] && printf "$FMT_ERROR" "Can not use encryption: mkrypt is not installed at given path: $mkrypt."

# if using a config
if [[ -n $config ]]; then
    source $CONFIG_DIR$config || { printf "$FMT_ERROR" "Error running the config file: $CONFIG_DIR/$config"; exit 1; }
    if [[ $use_encryption = 1 ]]; then
        [[ -z $reverse ]] && encrypt=1 || decrypt=1
    fi
    [[ $v -ge 3 ]] && printf "$FMT_MESSAGE" "Loaded config: $CONFIG_DIR$config:: date:$date sender:$sender receiver:$receiver use_encryption:$use_encryption encrypt:$encrypt decrypt:$decrypt paths:${paths[*]}"
fi

# overwrite stuff from the config if anything else was given / set variables of no config was given
[[ -n $sender_2 ]] && sender=$sender_2
[[ -n $receiver_2 ]] && receiver=$receiver_2
[[ -z $sender ]] && {
    [[ $v -ge 1 ]] && printf "$FMT_MESSAGE" "Missing sender. Using working directory: $(pwd)"; 
    sender="$(pwd)/"
}

# reverse: swap sender and reveiver
if [[ -n $reverse ]]; then
    tmp_sender=$sender
    sender=$receiver 
    receiver=$tmp_sender
fi

# make sure receiver has trailing slash
[[ $receiver != *"/" ]] && receiver=$receiver"/"
# create receiver dir if its local
[[ ! $receiver == *:* ]] && { mkdir -p $receiver || { printf "$FMT_ERROR" "Can not create receiver directory: $receiver"; exit 1; }}

[[ $v -ge 3 ]] && printf "$FMT_MESSAGE" "sender:$sender receiver:$receiver paths:$paths paths_2:$paths_2"

# filter paths: 
# - if using config: all paths from config that have a pos.arg in them
# - else: pos.args, must be relative to specified --sender
filtered_paths=()
if [[ -n $config ]]; then
    [[ $sender != *"/" ]] && sender=$sender"/"
    for path in ${paths[@]}; do
        if check_path_in_args; then
            filtered_paths+=($sender$path)
        fi
    done
else
    for path in ${paths_2[@]}; do  # add slash if directory
        [[ -d $path ]] && [[ $path != *"/" ]] && path=$path"/"
        filtered_paths+=($sender$path)
    done
fi
[[ $v -ge 3 ]] && printf "$FMT_MESSAGE" "Filtered paths: ${filtered_paths[@]}"

# sanity checks
[[ -z $filtered_paths ]] && { printf "$FMT_ERROR" "Missing valid paths."; exit 1; }
[[ -z $receiver ]] && { printf "$FMT_ERROR" "Missing receiver. Specifiy with --receiver"; exit 1; }

# if using --date
if [[ -n $use_date && -z $date ]]; then  # if --date but date is not set, use 0 (unix time)
    [[ $v -ge 1 ]] && printf "$FMT_MESSAGE" "--date passed but date not set in config, using 0 (unix time)"
    date=$(date -d @0)
fi
[[ -n $use_date ]] && mkrypt_flags+=("--date \"${date}\"")

# RUN!
sync_sender_to_receiver
exit 0