#!/bin/bash
# -*- tab-width:4;indent-tabs-mode:nil -*-
# ex: ts=4 sw=4 et

RUNNER_SCRIPT_DIR={{{mongooseim_script_dir}}}

RUNNER_BASE_DIR="${RUNNER_SCRIPT_DIR%/*}"
RUNNER_ETC_DIR="{{mongooseim_etc_dir}}"
RUNNER_LOG_DIR="{{mongooseim_log_dir}}"
# Note the trailing slash on $PIPE_DIR/
PIPE_DIR=/tmp/mongooseim_pipe_`whoami`/
RUNNER_USER={{mongooseim_runner_user}}

EJABBERD_PID_PATH="{{mongooseim_pid_dir}}/pid"
export EJABBERD_PID_PATH="$EJABBERD_PID_PATH"

EJABBERD_STATUS_PATH="{{mongooseim_status_dir}}/status"
export EJABBERD_STATUS_PATH="$EJABBERD_STATUS_PATH"

EJABBERD_CONFIG_PATH=${EJABBERD_CONFIG_PATH:-$RUNNER_ETC_DIR/mongooseim.${MONGOOSEIM_CONFIG_FORMAT:-toml}}
export EJABBERD_CONFIG_PATH

# Make sure this script is running as the appropriate user
if [ ! -z "$RUNNER_USER" ] && [ `whoami` != "$RUNNER_USER" ]; then
    exec runuser -l "$RUNNER_USER" -c "$0 $*"
fi

# Make sure CWD is set to runner base dir
cd "$RUNNER_BASE_DIR"

# Make sure log directory exists
mkdir -p "$RUNNER_LOG_DIR"

# Save possible erl_crash.dump in log directory
export ERL_CRASH_DUMP="${RUNNER_LOG_DIR}/erl_crash.dump"

# Extract the target node name from node.args
NAME_ARG=`grep -E '^-s?name' "$RUNNER_ETC_DIR"/vm.args`
if [ -z "$NAME_ARG" ]; then
    echo "vm.args needs to have either -name or -sname parameter."
    exit 1
fi
NAME=$(echo $NAME_ARG | awk '{print $1}')
NODE=$(echo $NAME_ARG | awk '{print $2}')
HOST=$(echo $NODE | awk -F@ '{ print $2 }')
if [ -z "$HOST" ]; then
    case $NAME in
        "-sname") HOST=$(hostname -s) ;;
        "-name")  HOST=$(hostname -f) ;;
    esac
    NODE=$NODE@$HOST
fi
MNESIA_DIR={{mongooseim_mdb_dir}}

# Extract the target cookie
COOKIE_ARG=`grep -e '^-setcookie' "$RUNNER_ETC_DIR"/vm.args`
if [ -z "$COOKIE_ARG" ]; then
    echo "vm.args needs to have a -setcookie parameter."
    exit 1
fi

# Identify the script name
SCRIPT=`basename "$0"`

# Parse out release and erts info
START_ERL=`cat "$RUNNER_BASE_DIR"/releases/start_erl.data`
ERTS_VSN="${START_ERL% *}"
APP_VSN="${START_ERL#* }"

# Add ERTS bin dir to our path
ERTS_PATH="$RUNNER_BASE_DIR/erts-$ERTS_VSN/bin"

# Setup command to control the node
function nodetool {
    "$ERTS_PATH"/escript "$ERTS_PATH"/nodetool $NAME_ARG $COOKIE_ARG "$@"
}

function exec_echo {
    echo "Exec: $@"
    exec "$@"
}

# Generate a random id
relx_gen_id() {
    od -t x -N 4 /dev/urandom | head -n1 | awk '{print $2}'
}

is_zombie() {
    local PID=$1
    # PROCESS STATE CODES from "man ps"
    # Z    defunct ("zombie") process, terminated but not reaped by its parent.
    ps aux | awk '$8 ~ /Z/ { printf("%s, PID = %d\n", $8, $2); }' | grep "$PID"
}

wait_for_pid_exit() {
    local PID=$2
    DURATION=0
    while `kill -0 $PID 2>/dev/null`;
    do
        sleep 1
        echo "Waiting for $PID for $DURATION seconds"
        DURATION=$(($DURATION + 1))
        if [ "$1" = "force_stop" ] && [ "$DURATION" = 30 ]; then
            echo "Force kill $PID using SIGTERM"
            kill -15 "$PID"
        fi
        if [ "$1" = "force_stop" ] && [ "$DURATION" = 60 ]; then
            echo "Force kill $PID using SIGKILL"
            kill -9 "$PID"
        fi
        if is_zombie $PID ; then
            echo "$PID is zombie (defunct), stop waiting"
            exit 0
        fi
    done
}

# Check the first argument for instructions
case "$1" in
    start)
        # Make sure there is not already a node running
        RES=`nodetool ping`
        if [ "$RES" = "pong" ]; then
            echo "Node is already running!"
            exit 1
        fi
        HEART_COMMAND="$RUNNER_BASE_DIR/bin/$SCRIPT start"
        export HEART_COMMAND
        mkdir -p "$PIPE_DIR"
        mkdir -p $(dirname "$EJABBERD_PID_PATH") || echo "Failed to create directory for $EJABBERD_PID_PATH"

        shift # remove $1
        "$ERTS_PATH"/run_erl -daemon "$PIPE_DIR" "$RUNNER_LOG_DIR" "exec \"$RUNNER_BASE_DIR/bin/$SCRIPT\" console $@" 2>&1
        ;;

    stop|force_stop)
        # Wait for the node to completely stop...
        PID=$(cat "$EJABBERD_PID_PATH" || echo "no_pid")
        nodetool stop
        if [ "$PID" = "no_pid" ]; then
            echo "Pid file $EJABBERD_PID_PATH is missing! The node can still be running though."
        else
            wait_for_pid_exit "$1" "$PID"
        fi
        ;;
    restart)
        ## Restart the VM without exiting the process
        nodetool restart
        ;;

    reboot)
        ## Restart the VM completely (uses heart to restart it)
        nodetool reboot
        ;;

    ping)
        ## See if the VM is alive
        nodetool ping
        ;;

    attach)
        # Make sure a node IS running
        RES=`nodetool ping`
        if [ "$RES" != "pong" ]; then
            echo "Node is not running!"
            exit 1
        fi

        shift
        "$ERTS_PATH"/to_erl "$PIPE_DIR"
        ;;

    console|live|console_clean|foreground)
        # .boot file typically just $SCRIPT (ie, the app name)
        # however, for debugging, sometimes start_clean.boot is useful:
        FOREGROUNDOPTIONS=""
        case "$1" in
            console|live)   BOOTFILE="start" ;;
            console_clean)  BOOTFILE=start_clean ;;
            foreground)
                # start up the release in the foreground for use
                # by supervision services (e.g. systemd, upstart)
                BOOTFILE="start"
                FOREGROUNDOPTIONS="-noshell -noinput +Bd"
                ;;
        esac
        # Setup beam-required vars
        ROOTDIR="$RUNNER_BASE_DIR"
        BINDIR="$ROOTDIR/erts-$ERTS_VSN/bin"
        EMU=beam
        PROGNAME=`echo $0 | sed 's/.*\\///'`

        export EMU
        export ROOTDIR
        export BINDIR
        export PROGNAME

        mkdir -p $(dirname "$EJABBERD_PID_PATH") || echo "Failed to create directory for $EJABBERD_PID_PATH"

        # Dump environment info for logging purposes
        echo "Root: $ROOTDIR"

        # Log the startup
        logger -t "$SCRIPT[$$]" "Starting up"

        # Start the VM
        exec_echo "$BINDIR/erlexec" $FOREGROUNDOPTIONS \
            -boot "$RUNNER_BASE_DIR/releases/$APP_VSN/$BOOTFILE" \
            -embedded \
            -config "$RUNNER_ETC_DIR/app.config" \
            -args_file "$RUNNER_ETC_DIR/vm.args"  \
            -args_file "$RUNNER_ETC_DIR/vm.dist.args" \
            -- ${1+"$@"}
        ;;

    debug)
        echo "--------------------------------------------------------------------"
        echo ""
        echo "IMPORTANT: we will attempt to attach an INTERACTIVE shell"
        echo "to an already running ejabberd node."
        echo "If an ERROR is printed, it means the connection was not successful."
        echo "You can interact with the ejabberd node if you know how to use it."
        echo "Please be extremely cautious with your actions,"
        echo "and exit immediately if you are not completely sure."
        echo ""
        echo "To detach this shell from ejabberd, press:"
        echo "  control+c, control+c"
        echo ""
        echo "--------------------------------------------------------------------"
        echo "Press 'Enter' to continue"
        read
        echo ""
        id=$(relx_gen_id)

        ROOTDIR="$RUNNER_BASE_DIR"
        BINDIR="$ROOTDIR/erts-$ERTS_VSN/bin"
        PROGNAME=`echo $0 | sed 's/.*\\///'`

        # Log the startup
        logger -t "$SCRIPT[$$]" "Starting up"

        export BINDIR

        # Start the VM
        exec_echo "$BINDIR/erlexec" -boot "$RUNNER_BASE_DIR/releases/$APP_VSN/start_clean" "$NAME" "debug-$id-$NODE" $COOKIE_ARG -remsh "$NODE" -hidden -args_file "$RUNNER_ETC_DIR/vm.dist.args"
        ;;

    version)
        if [ $# == 2 ] && [ "$2" == '--simple' ]
        then
            cat "$RUNNER_BASE_DIR/priv/VERSION"
        else
            cat "$RUNNER_BASE_DIR/priv/logo.txt"
            echo -n "MongooseIM version "
            cat "$RUNNER_BASE_DIR/priv/VERSION"
        fi
        ;;
    *)
        echo "Usage: $SCRIPT {start|stop|force_stop|restart|reboot|ping|live|console|console_clean|foreground|attach|debug|version}"
        exit 1
        ;;
esac

exit 0
