#!/bin/sh
#-----------------------------------------------------------------------------
# /var/install/bin/postgresql-common-restore-server
#
# Creation:     2019-03-28 dv
# Last Update:  2023-07-23 09:11:10
#
# Copyright (c) 2024 the eisfair team, team(at)eisfair(dot)org
#
# 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.
#-----------------------------------------------------------------------------

. /var/install/include/eislib
. /var/install/bin/postgresql-common-browser-helpers

#-----------------------------------------------------------------------------
# show help on arguments and possible options
# @param  n/a
# @return n/a
#-----------------------------------------------------------------------------
show_help()
{
cat <<EOF

Restore PostgreSQL database cluster

usage: ${0} [OPTIONS]

options:
   --help              show this help screen
   --user=<user>       database user [postgres]
   --mount=<cmd>       action to perform before restore
   --umount=<cmd>      action to perform after restore
   --folder=<path>     output folder [/tmp]
   --port=<portno>     database service port [5432]
   --bin-dir=<dir>     path where postgresql tools reside [/usr/bin]

EOF

}

# ---------------------------------------------------------------------------
#  show wait animation
#  @return n/a
# ---------------------------------------------------------------------------
show_wait()
{
    mecho -n "wait [ "
    colpos=1
    while [ -n "$(ps --no-headers $!)" ]
    do
        mecho -info -n "."
        sleep 1
        colpos=$((${colpos} + 1))
        if [ "${colpos}" -ge 55 ]
        then
            mecho " ]"
            mecho -n "wait [ "
            colpos=1
        fi
    done
    mecho " ] done"
}

# ---------------------------------------------------------------------------
#  move the cursor to the specified screen position
#  @param  $1  X cursor position
#  @param  $2  Y cursor position
#  @return n/a
# ---------------------------------------------------------------------------
gotoxy()
{
    echo -e "\033[$2;$1H\c";
}

# ---------------------------------------------------------------------------
# execute database query
# @param  query to execute
# ---------------------------------------------------------------------------
run_query()
{
    echo "${1}" | \
        ${bin_dir}/psql -p "${port}" template1 postgres -t -A
}

# ---------------------------------------------------------------------------
# connect to server and query version
# @return  0 on success, 1 on failure
# ---------------------------------------------------------------------------
identify_server()
{
    local result=$(run_query "SELECT version();")
    if [ "${?}" -eq "0" ]
    then
        server=$(echo ${result} | cut -d\| -f1)
        server=$(echo ${server} | cut -d\, -f1)
        return 0
    fi

    return 1
}

# ---------------------------------------------------------------------------
# wait for user to acknowledge settings done by previous steps
# @return  0 on success, 1 if used did abort, 127 if user wants to exit menu
# ---------------------------------------------------------------------------
user_acknowledge()
{
    clrhome

    # print table heading
    mecho --info "SERVER RESTORE - ${server}"
    echo
    mecho --info "STEP 3: Final Acknowledgement:"
    echo
    echo "If you proceed, the following settings will be used"
    echo "to restore the database cluster:"
    echo

    # print summary of settings
    mecho --info -n "Backup File:   "
    echo "${filename}"
    mecho --info -n "Backup Folder: "
    echo "${folder}"
    mecho --info -n "Database User: "
    echo "${user}"
    echo

    # get final acknowledge
    local ask_file=$(mktemp -t .XXXXXXXXX)
    local rc
    local ok_to_restore

    /var/install/bin/ask "Continue" "y" >${ask_file}
    rc=${?}
    ok_to_restore=$(cat ${ask_file})
    rm -f ${ask_file}

    if [ ${rc} = 255 ]
    then
        return 127
    fi

    if [ "${ok_to_restore}" = "yes" ]
    then
        return 0
    else
        return 1
    fi
}

# ---------------------------------------------------------------------------
# perform database restoration
# @return  0 on success, 1 in case of error
# ---------------------------------------------------------------------------
perform_restore()
{
    clrhome

    # print table heading
    mecho --info "SERVER RESTORE - ${server}"
    echo
    mecho --info "STEP 4: Restoration of database:"
    echo

    # perform restoration
    zcat "${folder}/${filename}" | ${bin_dir}/psql \
        -p "${port}" \
        -U "${user}" \
        -d postgres  \
        > /dev/null 2> /tmp/psql_log$$ &

    # entertain the user
    show_wait

    # evaluate exit code
    wait $!

    if [ "${?}" = "0" ]
    then
        mecho
        mecho --info "Restoration succeeded!"
        mecho
        rm -f /tmp/psql_log$$
        return 0
    else
        mecho
        mecho --error "Restoration failed!"
        mecho
        mecho --error "$(cat /tmp/psql_log$$)"
        rm -f /tmp/psql_log$$
        return 1
    fi
}

# ---------------------------------------------------------------------------
# perform optional mount operation
# @return  0 on success, 1 in case of error
# ---------------------------------------------------------------------------
perform_mount()
{
    if [ -n "${mount}" ]
    then
        eval ${mount} 2>&1
        if [ "$?" -ne "0" ]
        then
            echo "error: failed to mount backup volume!" >&2
            return 1
        fi
    fi
    return 0
}

# ---------------------------------------------------------------------------
# perform optional unmount operation
# @return  0 on success, 1 in case of error
# ---------------------------------------------------------------------------
perform_umount()
{
    # do umount step if required
    if [ -n "${umount}" ]
    then
        eval ${umount} 2>&1
        if [ "$?" -ne "0" ]
        then
            echo "error: failed to unmount backup volume!" >&2
            return 1
        fi
    fi
}

# ---------------------------------------------------------------------------
# main routine
# ---------------------------------------------------------------------------
main()
{
    port="5432"
    user="postgres"
    folder="/tmp"
    bin_dir="/usr/bin"
    re_create="no"

    # read option switches
    while [ "${1:0:2}" = "--" ]
    do
        case ${1} in
        --help)
            show_help
            exit 0
            ;;
        --bin-dir)
            shift
            bin_dir="${1}"
            shift
            ;;
        --bin-dir=*)
            bin_dir="${1:10}"
            shift
            ;;
        --user)
            shift
            user="${1}"
            shift
            ;;
        --user=*)
            user="${1:7}"
            shift
            ;;
        --mount)
            shift
            mount_cmd="${1}"
            shift
            ;;
        --mount=*)
            mount_cmd="${1:8}"
            shift
            ;;
        --umount)
            shift
            umount_cmd="${1}"
            shift
            ;;
        --umount=*)
            umount_cmd="${1:9}"
            shift
            ;;
        --folder)
            shift
            folder="${1}"
            shift
            ;;
        --folder=*)
            folder="${1:9}"
            shift
            ;;
        --file-limit)
            shift
            file_limit="${1}"
            shift
            ;;
        --file-limit=*)
            file_limit="${1:13}"
            shift
            ;;
        --port)
            shift
            port="${1}"
            shift
            ;;
        --port=*)
            port="${1:7}"
            shift
            ;;
        *)
            echo "error: invalid option switch \"$1\"!" >&2
            exit 1
            ;;
        esac
    done

    if [ "$#" -gt "0" ]
    then
        echo "error: invalid option switch \"$1\"!" >&2
        exit 1
    fi

    # fetch version from server
    if ! identify_server
    then
        exit 1
    fi

    # do mount step if required
    if ! perform_mount
    then
        exit 1
    fi

    # create backup folder (if not already present)
    mkdir -p "${folder}" 2>&1 >/dev/null

    # select backup to restore
    browse_backup_files                    \
        "SERVER RESTORE - ${server}"       \
        "STEP 1: Select file to restore from \"${folder}\":"  \
        "${folder}/*.dumpall.gz"           \
        "filename"
    rc="${?}"
    if [ "${rc}" -ne "0" ]
    then
        perform_umount
        exit ${rc}
    fi

    # select user to perform the operation
    browse_users                                                   \
        "SERVER RESTORE - ${server}"                               \
        "STEP 2: Select database user to perform the restoration:" \
        "user"
    rc="${?}"
    if [ "${rc}" -ne "0" ]
    then
        perform_umount
        exit ${rc}
    fi

    # wait for user acknowledgement
    if ! user_acknowledge
    then
        rc=${?}
        perform_umount
        exit ${rc}
    fi

    # perform restoration
    if ! perform_restore
    then
        perform_umount
        exit 1
    fi

    # do umount step if required
    if ! perform_umount
    then
        exit 1
    fi
}


# ---------------------------------------------------------------------------
# call function main
# ---------------------------------------------------------------------------
main "${@}"

exit 0

# ---------------------------------------------------------------------------
# end
# ---------------------------------------------------------------------------