homesync

#!/bin/bash

checkMountpoint() {
    if mountpoint -q "$1"; then
        true
    else
        false
    fi
}

checkDependencies() {
    dependencies=("inotifywait" "ldapsearch" "unison")

    for dep in "${dependencies[@]}"; do
        if [ ! "$(command -v "$dep")" ]; then
            fatal "[ERROR] Command $dep not installed." 
        fi
    done
}

checkLock() {
    exec {LOCK}>/var/lock/homesync-"$USER".lock 
    flock -x -n ${LOCK} || fatal "[INFO] Homesync already running for user $USER."
}

debug() {
    if [ "$(getConfig global DEBUG)" == "true" ]; then
        logfile=$(getConfig global LOG_FILE | sed "s|~|$HOME|")

        if [ ! -f "$logfile" ]; then
            touch "$logfile"
        fi

        exec 3>&1 1>"$logfile" 2>&1
        trap '{ set +x; } 2>/dev/null; echo -n "[$(date "+%d/%m/%Y %R")]  "; set -x' DEBUG
    fi
}

fatal() {
    echo "$@" >&2
    kill -10 $proc
}

getConfig() {
    val=$(awk '/^\[.*\]$/{obj=$0}/=/{print obj $0}' "$conf" | grep '^\['"$1"'\]'"$2"' = ' | sed -r 's/^([^=]+)= //')

    if [ -z "$val" ]; then
        if [ "$1" != "global" ]; then
            getConfig global "$2"
        else
            fatal "[ERROR] Configuration $2 not found in $conf."
        fi
    else
        echo "$val"
    fi
}

getMachine() {
    if [ "$ldapBind" != "false" ]; then
        ldapUser=$(ldapsearch -x -H "$ldapURL" -LLL -D "$ldapBind" -w "$ldapBindPW" -b "$ldapDN" cn="$USER")
    else
        ldapUser=$(ldapsearch -x -H "$ldapURL" -LLL -b "$ldapDN" cn="$USER")
    fi

    if [ "$?" -eq 0 ]; then
        echo "$ldapUser" | grep "$ldapMachineAttribute" | tr -d " " | cut -d ":" -f 2
    else
        fatal "[ERROR] LDAP bind failed."
    fi
}

getName() {
    getent passwd "$USER" | cut -d ":" -f 5 | cut -d " " -f 1
}

getShell() {
    getent passwd "$USER" | cut -d ":" -f 7
}

setupHome() {
    userShell=$(getShell)
    homesyncStart="homesync -a"
    homesyncStop="homesync -s && homesync -k"
    storageRemoteBaseSize=$(du -s "$storageRemoteBase" 2> /dev/null | cut -f 1 | awk '1; END { if (NR == 0) printf "0"; }')

    if ! (( "$storageRemoteBaseSize" >=0 && "$storageRemoteBaseSize" <= 4 )); then
        if [ ! -d "$storageRemote" ] || [ -z "$(ls -A "$storageRemote")" ]; then
            for dir in "${storageDirsSync[@]}"; do
                mkdir -p "$storageRemote"/"$dir"
            done

            chmod -R 750 "$storageRemote"
        fi
    fi

    if [ "${storageDirsNoSync[0]}" != "false" ]; then
        if [ ! -d "$storageLocal" ] || [ -z "$(ls -A "$storageLocal")" ]; then
            for dir in "${storageDirsNoSync[@]}"; do
                mkdir -p "$storageLocal"/"$dir"
            done

            chmod -R 750 "$storageLocal"
        fi
    fi

    if [ ! -d "$homeLocal" ] || [ -z "$(ls -A "$homeLocal")" ]; then
        for dir in "${homeDirs[@]}"; do
            mkdir -p "$homeLocal"/"$dir"
        done

        for file in "${homeFiles[@]}"; do
            touch "$homeLocal"/"$file"
        done

        if [ "$userShell" == "/bin/bash" ]; then
            touch "$homeLocal"/.bash_history
        elif [ "$userShell" == "/bin/zsh" ]; then
            touch "$homeLocal"/.zsh_history
        fi

        chmod -R 700 "$homeLocal"
    fi

    if [ ! -d "$HOME" ] || [ -z "$(ls -A "$HOME")" ]; then
        if [ "$userShell" == "/bin/bash" ]; then
            ln -sf "$homeLocal"/.bash_history "$HOME"/.bash_history
            cp /etc/skel/.{bash_logout,bashrc} "$HOME"
            echo "$homesyncStop" >> "$HOME"/.bash_logout
        elif [ "$userShell" == "/bin/zsh" ]; then
            ln -sf "$homeLocal"/.zsh_history "$HOME"/.zsh_history
            echo "HISTFILE=/home/ldap/$USER/.zsh_history" > "$HOME"/.zshrc
            echo "$homesyncStart" >> "$HOME"/.zprofile
            echo "$homesyncStop" >> "$HOME"/.zlogout
        fi

        cp /etc/skel/.profile "$HOME"
        echo "$homesyncStart" >> "$HOME"/.profile

        for dir in "${homeDirs[@]}"; do
            ln -snf "$homeLocal"/"$dir" "$HOME"/"$dir"
        done

        for file in "${homeFiles[@]}"; do
            ln -sf "$homeLocal"/"$file" "$HOME"/"$file"

            if [ "$file" == ".viminfo" ]; then
                cat <<-EOF > "$HOME"/.vimrc
		source \$VIMRUNTIME/defaults.vim
		set viminfo+=n$homeLocal/$file
		EOF
            fi
        done
    fi
}

symlinksStorage() {
    if [ "$1" == "true" ]; then
        origin="$storageRemote"
    else
        origin="$storageLocal"
    fi

    for dir in "${storageDirsSync[@]}"; do
        ln -snf "$origin"/"$dir" "$HOME"/"$dir"
    done

    if [ "${storageDirsNoSync[0]}" != "false" ]; then
        for dir in "${storageDirsNoSync[@]}"; do
            ln -snf "$storageLocal"/"$dir" "$HOME"/"$dir"
        done
    fi

    ln -snf "$origin" "$HOME"/"$storageLocalName"
}

syncHandler() {
    if checkMountpoint "$storageRemoteBase"; then
        if [ "$HOSTNAME" == "$(getMachine)" ]; then
            syncRemote & 
        fi   
    fi
}

syncHome() {
    mount "$bindPath"
    syncMain "$HOME" "$bindPath""$HOME"
    umount "$bindPath"
}

syncMain() {
    if [ ! -d "$2" ]; then
        cp -rp "$1" "$2"
    elif [ -z "$(ls -A "$2")" ]; then
        cp -rp "$1"/* "$2"
    else
        if [ "$1" == "$HOME" ]; then
            unison "${unisonArgs[@]}" "$1" "$2"
        else
            unison "${unisonArgs[@]}" "${storageDirsSync[@]/#/-path=}" "$1" "$2"
        fi
    fi
}

syncRemote() {
    syncMain "$storageRemote" "$storageLocal"

    { inotifywait -r -m "$storageRemote" -e create -e delete -e modify -e move -e attrib --format "%w|%e|%f" |
        while IFS='|' read -r dir action file; do
            syncMain "$storageRemote" "$storageLocal"
        done }
}

usage() {
    cat <<-EOF
	Usage: homesync -arg
	    -a  Online: Sync roaming home with local home, and network share with local storage 
	        Offline: Change symlinks to local storage 
	    -d	Setup local home directory structure
	    -h	Show this help message and exit
	    -k	Kill all homesync processes started by the current user session
	    -l	Setup home directory symlinks according to mount status
	    -r	Only sync network share with local storage
	    -s	Only sync roaming home with the underlying directory
	EOF
}

if [ $# -gt 0 ] && [[ $1 == -* ]]; then
    proc=$$
    conf="/etc/homesync.conf"

    trap 'exit 1' SIGUSR1

    if [ -f $conf ]; then
        ldapURL=$(getConfig global LDAP_URL)
        ldapDN=$(getConfig global LDAP_DN)
        ldapBind=$(getConfig global LDAP_BIND)
        ldapBindPW=$(getConfig global LDAP_BIND_PW)
        ldapMachineAttribute=$(getConfig global LDAP_MACHINE_ATTRIBUTE)
        bindPath=$(getConfig global BIND_PATH)
        storageRemote=$(getConfig global STORAGE_REMOTE)/$(getName)
        storageRemoteBase=$(cut -d "/" -f -2 <<< "$storageRemote")
        storageLocal=$(getConfig global STORAGE_LOCAL)
        storageLocalName=$(getConfig global STORAGE_LOCAL_NAME)
        homeLocal=$(getConfig global HOME_LOCAL)/$USER
        read -r -a unisonArgs <<< "$(getConfig global UNISON_ARGS)"
        read -r -a storageDirsSync <<< "$(getConfig "$USER" STORAGE_DIRS_SYNC)"
        read -r -a storageDirsNoSync <<< "$(getConfig "$USER" STORAGE_DIRS_NOSYNC)"
        read -r -a homeDirs <<< "$(getConfig global HOME_DIRS)"
        read -r -a homeFiles <<< "$(getConfig global HOME_FILES)"
        export UNISON=$homeLocal/.unison

        while getopts 'adhklrs' arg; do
            case $arg in
                a)
                    checkLock
                    checkDependencies
                    debug

                    if checkMountpoint "$HOME"; then
                        setupHome
                        syncHome
                        symlinksStorage true
                        syncHandler 
                    elif [[ ! $(stat -f -L -c %T "$storageRemoteBase" 2> /dev/null) =~ ^(autofs|nfs|smb|^$) ]]; then
                        setupHome
                        syncHome
                        symlinksStorage true
                    else
                        symlinksStorage false
                    fi

                    exit
                    ;;
                d)
                    debug

                    if checkMountpoint "$HOME"; then
                        setupHome
                        symlinksStorage true
                    fi
                    ;;
                h)
                    usage
                    exit 
                    ;;
                k)
                    pkill -P "$(pgrep -t "$(tty | cut -d "/" -f 3-)" -o homesync)"
                    exit
                    ;;
                l)
                    debug

                    if checkMountpoint "$HOME"; then
                        symlinksStorage true
                    else
                        symlinksStorage false
                    fi

                    exit
                    ;;
                r)
                    checkLock
                    checkDependencies
                    debug

                    if checkMountpoint "$HOME"; then
                        syncHandler
                    fi

                    exit
                    ;;
                s)
                    checkDependencies
                    debug

                    if checkMountpoint "$HOME"; then
                        syncHome
                    elif [[ ! $(stat -f -L -c %T "$storageRemoteBase" 2> /dev/null) =~ ^(autofs|nfs|smb|^$) ]]; then
                        syncHome
                    fi

                    exit
                    ;;
                *)
                    usage
                    exit 1
                    ;;
            esac
        done
    else
        fatal "[ERROR] Configuration file not found." 
    fi
else
    echo "$0: missing argument"
    usage
    exit 1
fi