mc_common_functions.sh (2018-10-13)

#!/bin/bash
# Initial version from Minecraft wiki
# Heavily modified, customized and expanded by masa
# version x.x.x 2018-10-13 (YYYY-MM-DD)

export LANG=en_US.UTF-8
export LC_ALL=en_US.UTF-8

as_user() {
    ME=`whoami`

    if [ ${ME} == ${USERNAME} ] ; then
        bash -c "${1}"
    else
        su - ${USERNAME} -c "${1}"
    fi
}


mc_start() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    # Check that the server is not already running
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        echo "${L_PREFIX} [WARNING] mc_start(): ${SERVICE} is already running" | tee -a ${EVENT_LOG_FILE}
    else
        echo "${L_PREFIX} [INFO] mc_start(): Starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}

        if [ "${USE_TEMP_LOCATION}" = "true" ]
        then
            # Copy the save files rom the actual game directory to the run-time location inside /tmp
            copy_save_files_from_game_dir_to_tmp
            local RET=$?

            if [ $RET -ne 0 ]; then
                echo "${L_TIMESTAMP} [ERROR] mc_start(): Failed to copy over the save files!" | tee -a ${EVENT_LOG_FILE}
                exit 1
            fi
        fi

        # Start the server process
        as_user "cd ${INSTANCE_PATH} && screen -dmS ${SCREEN_SESSION} ${INVOCATION}"
        sleep ${POST_START_DELAY}

        # Verify that the server process was started successfully, by checking a few times in a delayed loop
        COUNTER=0

        while [ $COUNTER -lt ${START_GRACE_DELAY} ]
        do
            if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"

                echo "${L_PREFIX} [INFO] mc_start(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}

                # Create the state file to indicate that the server is/should be running
                as_user "touch ${STATE_FILE}"

                # Disable automatic saving?
                if [ ${START_TO_DISABLE_AUTOSAVE_DELAY} -ge 0 ]
                then
                    sleep ${START_TO_DISABLE_AUTOSAVE_DELAY}
                    mc_saveoff
                fi

                break
            fi

            sleep 1

            ((COUNTER += 1))
        done

        # If the loop counter hit the max value, the process was not started successfully
        if [ ${COUNTER} -ge ${START_GRACE_DELAY} ]
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            echo "${L_PREFIX} [ERROR] mc_start(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
        fi
    fi
}


mc_stop() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    # Check that the process is running
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        echo "${L_PREFIX} [INFO] mc_stop(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}

        if [ ${SAVEALL_STOP_INTERVAL} -ge 0 ]; then
            if [ "${1}" = "broadcast" ]; then
                as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER SHUTTING DOWN NOW. Saving the map...\"\015'"
            fi

            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-all\"\015'"
            sleep ${SAVEALL_STOP_INTERVAL}
        else
            if [ "${1}" = "broadcast" ]; then
                as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER SHUTTING DOWN NOW!!\"\015'"
                sleep 3
            fi
        fi

        as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"stop\"\015'"
        sleep ${POST_STOP_DELAY}

        # Check if the process was successfully stopped
        COUNTER=0
        while [ ${COUNTER} -lt ${STOP_GRACE_DELAY} ]; do

            if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                # Remove the state file to indicate that the server has been stopped gracefully
                as_user "rm ${STATE_FILE} > /dev/null 2>&1"

                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"
                echo "${L_PREFIX} [INFO] mc_stop(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}

                if [ "${USE_TEMP_LOCATION}" = "true" ]
                then
                    # Copy the save files from the temp directory (in RAM) into the actual server directory
                    copy_save_files_from_tmp_to_game_dir
                    local RET=$?

                    # If copying the save file succeeded, and this is not a restart, then remove the temp files
                    if [ $RET -eq 0 ] && [ "$1" != "true" ]
                    then
                        remove_save_files_from_tmp_location
                    fi
                fi

                break
            fi

            sleep 1

            ((COUNTER += 1))
        done

        if [ ${COUNTER} -ge ${STOP_GRACE_DELAY} ]
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            echo "${L_PREFIX} [ERROR] mc_stop(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
        fi
    else
        echo "${L_PREFIX} [WARNING] mc_stop(): ${SERVICE} was not running" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_restart() {
    # Use the arguments as override delay values, if they exist
    if [ -n "${1}" ]
    then
        RESTART_FIRST_WARNING=${1}

        if [ -n "${2}" ]
        then
            RESTART_LAST_WARNING=${2}
        fi
    fi

    # Check if the server process is running, and broadcast warning messages before stopping the server
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        if [ ${RESTART_FIRST_WARNING} -gt ${RESTART_LAST_WARNING} ]
        then
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_FIRST_WARNING} SECONDS\"\015'"
            ((DELAY = ${RESTART_FIRST_WARNING} - ${RESTART_LAST_WARNING}))
            sleep ${DELAY}
        fi

        as_user "screen -p 0 -S $SCREEN_SESSION -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_LAST_WARNING} SECONDS\"\015'"
        sleep ${RESTART_LAST_WARNING}

        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"
        echo "${L_PREFIX} [INFO] mc_restart(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}

        mc_stop "true"

        if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [INFO] mc_restart(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}
        fi
    fi

    # (Re-)Start the server
    if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"
        echo "${L_PREFIX} [INFO] mc_restart(): (Re-)starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}

        mc_start

        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"

        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            echo "${L_PREFIX} [INFO] mc_restart(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
        else
            echo "${L_PREFIX} [ERROR] mc_restart(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
        fi

    else
        echo "${L_PREFIX} [ERROR] mc_restart(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_restart_if_up() {
    # Use the arguments as override delay values, if they exist
    if [ -n "${1}" ]
    then
        RESTART_FIRST_WARNING=${1}

        if [ -n "${2}" ]
        then
            RESTART_LAST_WARNING=${2}
        fi
    fi

    # First check if the server is supposed to be running
    if [ -f "${STATE_FILE}" ]
    then
        # Check if the server process is running, and broadcast warning messages before stopping the server
        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            if [ ${RESTART_FIRST_WARNING} -gt ${RESTART_LAST_WARNING} ]
            then
                as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_FIRST_WARNING} SECONDS\"\015'"
                ((DELAY = ${RESTART_FIRST_WARNING} - ${RESTART_LAST_WARNING}))
                sleep ${DELAY}
            fi

            as_user "screen -p 0 -S $SCREEN_SESSION -X eval 'stuff \"say §dSERVER RESTARTING IN ${RESTART_LAST_WARNING} SECONDS\"\015'"
            sleep ${RESTART_LAST_WARNING}

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [INFO] mc_restart_if_up(): Stopping ${SERVICE}" | tee -a ${EVENT_LOG_FILE}

            mc_stop "true"
        fi

        # The server was running and was successfully stopped, or at least is supposed to be running. Now we start it up again.
        if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            echo "${L_PREFIX} [INFO] mc_restart_if_up(): ${SERVICE} has been stopped" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_restart_if_up(): Restarting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}

            mc_start

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                echo "${L_PREFIX} [INFO] mc_restart_if_up(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
            else
                echo "${L_PREFIX} [ERROR] mc_restart_if_up(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
            fi

        else
            echo "${L_PREFIX} [ERROR] mc_restart_if_up(): ${SERVICE} could not be stopped" | tee -a ${EVENT_LOG_FILE}
        fi
#   else
#       L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
#       L_PREFIX="${L_TIMESTAMP}"
#       echo "${L_PREFIX} [WARNING] mc_restart_if_up(): ${SERVICE} was not running" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_saveoff() {
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        if [ "${1}" = "broadcast" ];
        then
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dServer going read-only...\"\015'"
        fi

        as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-off\"\015'"
    fi
}


mc_saveon() {
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        if [ "${1}" = "broadcast" ];
        then
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dServer going read-write...\"\015'"
        fi

        as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-on\"\015'"
    fi
}


mc_saveall() {
    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        if [ "${1}" = "broadcast" ];
        then
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say §dSaving the map...\"\015'"
        fi

        as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"save-all\"\015'"
        sleep ${POST_SAVEALL_DELAY}
    fi
}


mc_sync() {
    if [ "${USE_TEMP_LOCATION}" = "true" ]; then
        # Check if the server process is running
        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            mc_say "§dSyncing world data to disk, server going read-only"
            mc_saveoff

            if [ ${SAVEALL_BACKUP_INTERVAL} -ge 0 ]; then
                mc_saveall
                sleep ${SAVEALL_BACKUP_INTERVAL}
            else
                sleep 2
            fi

            # Copy the save files from the temp directory (in RAM) into the actual server directory
            copy_save_files_from_tmp_to_game_dir

            mc_say "§dSyncing world data to disk finished, server going read-write"
            mc_saveon
        # Server not running, but the temp path exists
        elif [ -e "${WORLD_PATH_TMP}" ]; then
            # Copy the save files from the temp directory (in RAM) into the actual server directory
            copy_save_files_from_tmp_to_game_dir
        fi
    fi
}


copy_save_files_from_game_dir_to_tmp() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`

    if [ -z "${WORLD_PATH_TMP}" ] || [ -z "${WORLD_PATH_REAL}" ] || [ -z "${WORLD_PATH_SYMLINK}" ]
    then
        echo "Empty real or temp world path, or world path symlink name!"
        exit 1
    fi

    # Make the necessary temporary directories
    if [ ! -d "${WORLD_PATH_TMP}" ]
    then
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_game_dir_to_tmp(): Creating the temporary save directory '${WORLD_PATH_TMP}'" | tee -a ${EVENT_LOG_FILE}
        as_user "mkdir -p ${WORLD_PATH_TMP} > /dev/null 2>&1"
        as_user "chmod 1777 ${WORLD_PATH_TMP}"
    fi

    # The symlink does not point to the temp directory
    # (which means that it likely points to the real directory on disk, see remove_save_files_from_tmp_location())
    if [ -h "${WORLD_PATH_SYMLINK}" ] && [ `readlink -f ${WORLD_PATH_SYMLINK}` != "${WORLD_PATH_TMP}" ]
    then
        as_user "rm ${WORLD_PATH_SYMLINK} > /dev/null 2>&1"
    fi

    # No symlink present
    if [ ! -e "${WORLD_PATH_SYMLINK}" ]
    then
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_game_dir_to_tmp(): (Re-)Creating a symlink for the world directory to ${WORLD_PATH_TMP}" | tee -a ${EVENT_LOG_FILE}
        as_user "ln -s ${WORLD_PATH_TMP} ${WORLD_PATH_SYMLINK} > /dev/null 2>&1"
    fi

    echo "${L_TIMESTAMP} [INFO] copy_save_files_from_game_dir_to_tmp(): Going to copy the save files to the temp directory..." | tee -a ${EVENT_LOG_FILE}

    # Copy the save files from the "real save path" on disk to the temporary location (in RAM).
    # Note: -u to only copy newer files!
    as_user "rsync -au ${WORLD_PATH_REAL}/ ${WORLD_PATH_TMP} > /dev/null 2>&1"
    #as_user "rsync -auhv ${WORLD_PATH_REAL}/ ${WORLD_PATH_TMP}"
    local RET=$?

    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`

    if [ $RET -ne 0 ]; then
        echo "${L_TIMESTAMP} [ERROR] copy_save_files_from_game_dir_to_tmp(): Failed to copy over the save files" | tee -a ${EVENT_LOG_FILE}
        return 1
    else
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_game_dir_to_tmp(): Done copying files" | tee -a ${EVENT_LOG_FILE}
    fi
}


copy_save_files_from_tmp_to_game_dir() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    echo "${L_TIMESTAMP} [INFO] copy_save_files_from_tmp_to_game_dir(): Going to copy the save files from the temp directory to the instance directory" | tee -a ${EVENT_LOG_FILE}

    if [ -z "${WORLD_PATH_TMP}" ] || [ -z "${WORLD_PATH_REAL}" ]
    then
        echo "EMPTY PATH"
        exit 1
    fi

    if [ ! -e "${WORLD_PATH_TMP}" ]
    then
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_tmp_to_game_dir: temp directory '${WORLD_PATH_TMP}' does not exist, nothing to do"
        return 0
    fi


    # Sync any changed files from the temp location to the real save path (the -u flag only copies newer files)
    as_user "rsync -au ${WORLD_PATH_TMP}/ ${WORLD_PATH_REAL} > /dev/null"
    #as_user "rsync -auhv ${WORLD_PATH_TMP}/ ${WORLD_PATH_REAL}"
    local RET=$?

    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`

    if [ $RET -ne 0 ]; then
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_tmp_to_game_dir(): Error copying save files!" | tee -a ${EVENT_LOG_FILE}
        return 1
    else
        echo "${L_TIMESTAMP} [INFO] copy_save_files_from_tmp_to_game_dir(): Done copying files" | tee -a ${EVENT_LOG_FILE}
    fi
}


remove_save_files_from_tmp_location() {
    if [ -n ${INSTANCE_PATH_TMP} ]
    then
        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        echo "${L_TIMESTAMP} [INFO] remove_save_files_from_tmp_location(): Removing the save files from the temp directory..." | tee -a ${EVENT_LOG_FILE}

        as_user "rm -r --preserve-root ${INSTANCE_PATH_TMP} > /dev/null"

        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        echo "${L_TIMESTAMP} [INFO] remove_save_files_from_tmp_location(): Done removing files" | tee -a ${EVENT_LOG_FILE}

        # World path is a symlink
        #if [ -h "${WORLD_PATH_SYMLINK}" ]
        #then
        #   echo "${L_TIMESTAMP} [INFO] remove_save_files_from_tmp_location(): Changing the symlink to point to the real world" | tee -a ${EVENT_LOG_FILE}
        #   as_user "rm ${WORLD_PATH_SYMLINK} > /dev/null 2>&1"
        #   as_user "cd ${INSTANCE_PATH}"
        #   local WORLDNAME=`basename ${WORLD_PATH_REAL}`
        #   as_user "ln -s ${WORLDNAME} ${WORLD_PATH_SYMLINK} > /dev/null 2>&1"
        #fi
    fi
}


mc_backup() {
    TIMESTAMP_TAR=`date '+%Y-%m-%d_%H.%M.%S'`
    TIMESTAMP_GIT=`date '+%Y-%m-%d %H:%M'`

    if [ "${USE_TEMP_LOCATION}" = "true" ] && [ -e "${WORLD_PATH_TMP}" ]
    then
        # Copy the save files from the temp directory (in RAM) into the actual server directory
        copy_save_files_from_tmp_to_game_dir
        local RET=$?

        if [ $RET -ne 0 ]; then
            L_PREFIX=`date "+%Y-%m-%d %H:%M:%S"`
            echo "${L_PREFIX} [INFO] mc_backup(): Failed to copy save files from temp to game dir for instance '${INSTANCE}'" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Failed to copy save files from temp to game dir for instance '${INSTANCE}'" | tee -a ${BACKUP_LOG_FILE} > /dev/null
            return 1
        fi
    fi

    if [ "${BACKUP_USING_TAR}" = "true" ]
    then
        L_PREFIX=`date "+%Y-%m-%d %H:%M:%S"`

        if [ "${BACKUP_WORLD_ONLY}" = "true" ]
        then
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using tar" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using tar" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "cd ${INSTANCE_PATH} && tar --exclude '.git' -czpf ${BACKUP_PATH_TAR}/${BACKUP_PREFIX}_world_${TIMESTAMP_TAR}.tar.gz ${WORLD_NAME} | tee -a ${BACKUP_LOG_FILE} > /dev/null 2>&1"
        else
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using tar" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using tar" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "cd `dirname ${INSTANCE_PATH}` && tar --exclude '.git' -czpf ${BACKUP_PATH_TAR}/${BACKUP_PREFIX}_${TIMESTAMP_TAR}.tar.gz `basename ${INSTANCE_PATH}` | tee -a ${BACKUP_LOG_FILE} > /dev/null 2>&1"
        fi
    fi

    if [ "${BACKUP_USING_GIT}" = "true" ]
    then
        # Do we have an additional commit message?
        if [ -n "${1}" ]
        then
            MSG=" ${1}"
        else
            MSG=""
        fi

        if [ "${2}" = "true" ]
        then
            local GIT_PRM_ALLOW_EMPTY="--allow-empty"
        fi

        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"

        if [ "${BACKUP_WORLD_ONLY}" = "true" ]
        then
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using git" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using git" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "cd ${WORLD_PATH_REAL} && git add -A . | tee -a ${BACKUP_LOG_FILE} && git commit ${GIT_PRM_ALLOW_EMPTY} -m \"${TIMESTAMP_GIT}${MSG}\" | tee -a ${BACKUP_LOG_FILE}"
        else
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using git" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using git" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "cd ${INSTANCE_PATH} && git add -A . | tee -a ${BACKUP_LOG_FILE} && git commit ${GIT_PRM_ALLOW_EMPTY} -m \"${TIMESTAMP_GIT}${MSG}\" | tee -a ${BACKUP_LOG_FILE}"
        fi
    fi

    if [ "${BACKUP_USING_RESTIC}" = "true" ]
    then
        L_PREFIX=`date "+%Y-%m-%d %H:%M:%S"`

        if [ "${BACKUP_WORLD_ONLY}" = "true" ]
        then
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using restic" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the world of '${INSTANCE}' using restic" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "restic -r ${BACKUP_RESTIC_REPO} backup \"${INSTANCE_PATH}/${WORLD_NAME}\" --verbose --exclude \".git\" | tee -a ${BACKUP_LOG_FILE}"
        else
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using restic" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_backup(): Starting a backup of the server '${INSTANCE}' using restic" | tee -a ${BACKUP_LOG_FILE} > /dev/null

            as_user "restic -r ${BACKUP_RESTIC_REPO} backup \"${INSTANCE_PATH}\" --verbose --exclude \".git\" | tee -a ${BACKUP_LOG_FILE}"
        fi
    fi

    if [ "${BACKUP_SERVICE}" = "true" ]
    then
        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"

        echo "${L_PREFIX} [INFO] mc_backup(): Backing up service ${SERVICE}" | tee -a ${EVENT_LOG_FILE} > /dev/null
        as_user "cd ${INSTANCE_PATH} && cp -pn ${SERVICE} ${BACKUP_PATH}/${BACKUP_PREFIX}_${TIMESTAMP_TAR}.jar > /dev/null 2>&1"
    fi

    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"
    echo "${L_PREFIX} [INFO] mc_backup(): Backup of server instance '${INSTANCE}' complete" | tee -a ${EVENT_LOG_FILE} > /dev/null
    echo "${L_PREFIX} [INFO] mc_backup(): Backup of server instance '${INSTANCE}' complete" | tee -a ${BACKUP_LOG_FILE} > /dev/null
}

mc_backups_list() {
    if [ "${BACKUP_USING_RESTIC}" = "true" ]
    then
        L_PREFIX=`date "+%Y-%m-%d %H:%M:%S"`

        echo "${L_PREFIX} [INFO] mc_backups_list(): Listing latest backups of '${INSTANCE}' made with restic" | tee -a ${EVENT_LOG_FILE}

        as_user "restic -r ${BACKUP_RESTIC_REPO} snapshots | grep -E '[0-9]{4}-[0-9]{2}-[0-9]{2}' | cut -d' ' -f1-4 | tail -n 15"
    fi
}

mc_backup_wrapper() {
    if [ ${START_TO_DISABLE_AUTOSAVE_DELAY} -ge 0 ]
    then
        mc_say "§dSERVER BACKUP STARTING"

        if [ ${SAVEALL_BACKUP_INTERVAL} -ge 0 ]; then
            mc_saveall
            sleep ${SAVEALL_BACKUP_INTERVAL}
        else
            sleep 2
        fi

        mc_backup "${1}"

        mc_say "§dSERVER BACKUP FINISHED"
    else
        mc_say "§dSERVER BACKUP STARTING, server going read-only"
        mc_saveoff

        if [ ${SAVEALL_BACKUP_INTERVAL} -ge 0 ]; then
            mc_saveall
            sleep ${SAVEALL_BACKUP_INTERVAL}
        else
            sleep 5
        fi

        mc_backup "${1}"

        mc_say "§dSERVER BACKUP FINISHED, server going read-write"
        mc_saveon
    fi
}


mc_startifcrashed_basic() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    # If the state file is present, then the server is supposed to be running
    if [ -f "${STATE_FILE}" ]
    then
        # If the state file was present, but the process is not found, we assume that the server has crashed
        if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            echo "${L_PREFIX} [WARNING] mc_startifcrashed_basic(): ${SERVICE} is not running (crashed?)" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): Attempting to start ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}

            mc_start

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
            else
                echo "${L_PREFIX} [ERROR] mc_startifcrashed_basic(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
            fi
        else
            echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} is running" | tee -a ${EVENT_LOG_FILE}
        fi
    else
        echo "${L_PREFIX} [INFO] mc_startifcrashed_basic(): ${SERVICE} has been stopped gracefully" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_startifcrashed_ping() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    # If the state file is present, then the server is supposed to be running
    if [ -f "${STATE_FILE}" ]
    then
        # If the state file was present, and the process is found, we try to ping the server
        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is running, pinging it..." | tee -a ${EVENT_LOG_FILE}

            # We try the ping a maximum of PING_RETRY_COUNT times, to try and avoid false positive failures and restarts
            COUNTER=0
            while [ ${COUNTER} -lt ${PING_RETRY_COUNT} ]; do

                if ${PING_INVOCATION} | grep ': OK' > /dev/null
                then
                    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                    L_PREFIX="${L_TIMESTAMP}"

                    echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} responded to ping" | tee -a ${EVENT_LOG_FILE}
                    break
                fi

                sleep ${PING_RETRY_DELAY}
            done

            # If the ping failed every time, then we assume that the server has crashed and we will kill it and start it up again
            if [ ${COUNTER} -ge ${PING_RETRY_COUNT} ]
            then
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"

                echo "${L_PREFIX} [WARNING] mc_startifcrashed_ping(): ${SERVICE} doesn't respond to ping (crashed?)" | tee -a ${EVENT_LOG_FILE}
                echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): Killing and (re-)starting ${SERVICE}" | tee -a ${EVENT_LOG_FILE}

                mc_kill
                sleep ${KILL_TO_START_DELAY}
                mc_start

                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"

                if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
                then
                    echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
                else
                    echo "${L_PREFIX} [ERROR] mc_startifcrashed_ping(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
                fi
            fi
        else
            # Process not found (crashed?), we try to start the server
            echo "${L_PREFIX} [WARNING] mc_startifcrashed_ping(): ${SERVICE} not running (crashed?)" | tee -a ${EVENT_LOG_FILE}
            echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): Attempting to start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}

            mc_start

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"

            if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                echo "${L_PREFIX} [INFO] mc_startifcrashed_ping(): ${SERVICE} is now running" | tee -a ${EVENT_LOG_FILE}
            else
                echo "${L_PREFIX} [ERROR] mc_startifcrashed_ping(): Could not start ${SERVICE}" | tee -a ${EVENT_LOG_FILE}
            fi
        fi
    else
        # No state file present, the server is supposed to be down
        echo "${L_PREFIX} [INFO] mc_check(): ${SERVICE} has been stopped gracefully" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_kill() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
    then
        echo "${L_PREFIX} [INFO] mc_kill(): Killing minecraft server instance '${INSTANCE}'..." | tee -a ${EVENT_LOG_FILE}

        as_user "pkill -SIGKILL -u ${USERNAME} -f ${SERVICE}"
        sleep ${POST_KILL_DELAY}

        COUNTER=0
        while [ ${COUNTER} -lt ${KILL_GRACE_DELAY} ]; do
            if ! pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
            then
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"
                echo "${L_PREFIX} [INFO] mc_kill(): Server instance '${INSTANCE}' has been killed" | tee -a ${EVENT_LOG_FILE}

                # FIXME: Could this be done cleaner?
                screen -wipe

                if [ "${USE_TEMP_LOCATION}" = "true" ]
                then
                    # Copy the save files from the temp directory (in RAM) into the actual server directory
                    copy_save_files_from_tmp_to_game_dir
                    local RET=$?

                    if [ $RET -eq 0 ]; then
                        remove_save_files_from_tmp_location
                    fi
                fi

                break
            fi

            sleep 1

            ((COUNTER += 1))
        done

        if [ ${COUNTER} -ge ${KILL_GRACE_DELAY} ]
        then
            echo "${L_PREFIX} [ERROR] mc_kill(): Unable to kill minecraft server '${INSTANCE}'" | tee -a ${EVENT_LOG_FILE}
        fi
    else
        echo "${L_PREFIX} [WARNING] mc_kill(): Minecraft server instance '${INSTANCE}' was not running" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_download_server() {
    # Only do something if we have a version argument
    if [ -n "${1}" ]
    then
        VERSION="${1}"
        # If the requested server version doesn't yet exist, we attempt to download it
        if [ ! -f "${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" ]
        then
            MC_SERVER_URL="https://s3.amazonaws.com/Minecraft.Download/versions/${VERSION}/minecraft_server.${VERSION}.jar"
            as_user "wget -q -O \"${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar\" ${MC_SERVER_URL}"

            # If wget returns 0
            if [ "$?" -eq "0" ]
            then
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"
                echo "${L_PREFIX} [INFO] mc_download_server(): Downloaded ${MC_SERVER_URL} to ${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" | tee -a ${EVENT_LOG_FILE}
            else
                # Download failed
                echo "${L_PREFIX} [ERROR] mc_download_server(): Download of ${MC_SERVER_URL} failed" | tee -a ${EVENT_LOG_FILE}
                # Remove the empty file just created
                as_user "rm ${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar"
                exit 1
            fi
        fi
    fi
}


mc_update() {
    CURRENT_VERSION=`readlink -f "${INSTANCE_PATH}/${SERVICE}" | sed "s/.*\/${SERVER_FILE_PREFIX}\(.*\)\.jar/\1/"`

    # Any version change via this script on this server instance is forbidden
    if [ "${ALLOW_UPDATES}" = 'false' ] && [ "${ALLOW_DOWNGRADES}" = 'false' ]
    then
        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"
        echo "${L_PREFIX} [ERROR] mc_update(): Any updates or downgrades of '${SERVICE}' are not allowed (@ ${CURRENT_VERSION})" | tee -a ${EVENT_LOG_FILE}
        return
    fi

    if [ -z "${1}" ]
    then
        # No version specified, assume we want the latest stable release
        VERSIONS_URL="https://launchermeta.mojang.com/mc/game/version_manifest.json"
        # Old URL: VERSIONS_URL="https://s3.amazonaws.com/Minecraft.Download/versions/versions.json"

        as_user "wget -q -O ${VERSIONS_JSON} ${VERSIONS_URL}"

        # Get the latest[release] value
        VERSION=`tr '\r\n' ' ' < ${VERSIONS_JSON} | sed "s/ //g" | sed 's/.*\("latest[^}]\+}\).*/\1/' | sed 's/.*"release":"\([^"]\+\)"}/\1/'`
    else    # Use the version given as an argument
        VERSION="${1}"
    fi

    echo "Target version: ${VERSION}, Current version: ${CURRENT_VERSION}"
    #exit

    # If the requested version is different from the current version
    if [ "${CURRENT_VERSION}" != "${VERSION}" ]
    then
        # Check that the requested version change is permitted
        # FIXME This won't work correctly with alpha, beta etc. prefixed versions
        if [[ "${VERSION}" < "${CURRENT_VERSION}" ]] && [ "${ALLOW_DOWNGRADES}" != 'true' ]
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [ERROR] mc_update(): Downgrades of '${SERVICE}' are not allowed (${CURRENT_VERSION} -> ${VERSION})" | tee -a ${EVENT_LOG_FILE}
            return
        fi
        # FIXME This won't work correctly with alpha, beta etc. prefixed versions
        if [[ "${VERSION}" > "${CURRENT_VERSION}" ]] && [ "${ALLOW_UPDATES}" != 'true' ]
        then
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [ERROR] mc_update(): Updates of '${SERVICE}' are not allowed (${CURRENT_VERSION} -> ${VERSION})" | tee -a ${EVENT_LOG_FILE}
            return
        fi

        # If the server is currently running, broadcast a message before starting the update process
        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            RUNNING="true"

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [INFO] mc_update(): ${SERVICE} is running, stopping it and starting the update" | tee -a ${EVENT_LOG_FILE}

            mc_say "§d=== SERVER UPDATE STARTING ==="
            sleep 5
            mc_stop "broadcast"
        else
            RUNNING="false"

            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [INFO] mc_update(): ${SERVICE} is stopped, starting the update" | tee -a ${EVENT_LOG_FILE}
        fi

        mc_backup "Backup before updating to version ${VERSION} (@ ${CURRENT_VERSION})" "true"
        mc_download_server ${VERSION}

        # If the requested server file exists, update the symlink
        if [ -f "${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar" ]
        then
            as_user "ln -fs \"${SERVER_FILES_PATH}/${SERVER_FILE_PREFIX}${VERSION}.jar\" \"${INSTANCE_PATH}/${SERVICE}\""

            if [ "${RUNNING}" = "true" ]
            then
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"
                echo "${L_PREFIX} [INFO] mc_update(): Updated '${SERVICE}' to version '${VERSION}', starting ${SERVICE}..." | tee -a ${EVENT_LOG_FILE}

                mc_start
            else
                L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
                L_PREFIX="${L_TIMESTAMP}"
                echo "${L_PREFIX} [INFO] mc_update(): Updated '${SERVICE}' to version '${VERSION}'" | tee -a ${EVENT_LOG_FILE}
            fi
        else
            # Download failed
            L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
            L_PREFIX="${L_TIMESTAMP}"
            echo "${L_PREFIX} [ERROR] mc_update(): Update of '${SERVICE}' to version '${VERSION}' failed" | tee -a ${EVENT_LOG_FILE}
        fi
    else
        L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
        L_PREFIX="${L_TIMESTAMP}"
        echo "${L_PREFIX} [WARNING] mc_update(): '${SERVICE}' is already at version '${VERSION}', not doing anything" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_say() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    if [ -n "${1}" ]
    then
        MSG="${1}"

        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
#           echo "${L_PREFIX} [INFO] mc_say(): ${SERVICE} is running, saying '${MSG}'" | tee -a ${EVENT_LOG_FILE}
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"say ${MSG}\"\015'"
#       else
#           echo "${L_PREFIX} [WARNING] mc_say(): ${SERVICE} is not running" | tee -a ${EVENT_LOG_FILE}
        fi
    else
        echo "${L_PREFIX} [ERROR] mc_say(): You must specify a message" | tee -a ${EVENT_LOG_FILE}
    fi
}


mc_command() {
    L_TIMESTAMP=`date "+%Y-%m-%d %H:%M:%S"`
    L_PREFIX="${L_TIMESTAMP}"

    if [ "${1}" ]
    then
        command="${1}"

        if pgrep -u ${USERNAME} -f ${SERVICE} > /dev/null
        then
            echo "${L_PREFIX} [INFO] mc_command(): ${SERVICE} is running, executing command '${command}'" | tee -a ${EVENT_LOG_FILE}
            as_user "screen -p 0 -S ${SCREEN_SESSION} -X eval 'stuff \"${command}\"\015'"
        fi
    else
        echo "${L_PREFIX} [ERROR] mc_command(): You must specify a server command" | tee -a ${EVENT_LOG_FILE}
    fi
}