#!/bin/bash

source $OPENSHIFT_CARTRIDGE_SDK_BASH
source "${OPENSHIFT_PYTHON_DIR}usr/versions/${OPENSHIFT_PYTHON_VERSION}/lib/create-virtenv"
source "${OPENSHIFT_PYTHON_DIR}usr/versions/${OPENSHIFT_PYTHON_VERSION}/lib/python_config"

HTTPD_CFG_FILE=${OPENSHIFT_PYTHON_DIR}etc/conf/httpd_nolog.conf
HTTPD_CFG_DIR=${OPENSHIFT_PYTHON_DIR}etc/conf.d/
ERB_HTTPD_CFG_DIR=${OPENSHIFT_PYTHON_DIR}usr/versions/${OPENSHIFT_PYTHON_VERSION}/etc/conf.d/
HTTPD_PASSENV_FILE=${HTTPD_CFG_DIR}passenv.conf
HTTPD_PID_FILE=${OPENSHIFT_PYTHON_DIR}run/httpd.pid

# construct the configuration directives for httpd
HTTPD_CMD_CONF="-C 'Include ${HTTPD_CFG_DIR}*.conf' -f $HTTPD_CFG_FILE"
for dir in /etc/openshift/cart.conf.d/httpd{,/python} ; do
    [ -d $dir ] && HTTPD_CMD_CONF="$HTTPD_CMD_CONF -c 'Include $dir/*.conf'"
done

# For backwards compatibility
export APPDIR=$OPENSHIFT_PYTHON_DIR

function start_app() {
    echo "Starting Python ${OPENSHIFT_PYTHON_VERSION} cartridge (app.py server)"
    cd "$OPENSHIFT_REPO_DIR"

    LOGPIPE=${OPENSHIFT_HOMEDIR}/app-root/runtime/logshifter-python
    rm -f $LOGPIPE && mkfifo $LOGPIPE

    /usr/bin/logshifter -tag python < $LOGPIPE &
    nohup python -u app.py &> $LOGPIPE &

    if [ "$?" == "0" ]; then
      echo $! > $OPENSHIFT_PYTHON_DIR/run/appserver.pid
    else
      echo "ERROR: Application failed to start, use 'rhc tail' for more informations."
    fi
}

function pre_start_apache_config {
    write_httpd_passenv $HTTPD_PASSENV_FILE
    select_python_document_root ${OPENSHIFT_REPO_DIR}
    select_python_wsgi_application ${OPENSHIFT_REPO_DIR}
    oo-erb ${ERB_HTTPD_CFG_DIR}openshift.conf.erb > ${HTTPD_CFG_DIR}openshift.conf
    oo-erb ${OPENSHIFT_PYTHON_DIR}conf/performance.conf.erb.hidden > ${HTTPD_CFG_DIR}performance.conf
}

function start_apache() {
    echo "Starting Python ${OPENSHIFT_PYTHON_VERSION} cartridge (Apache+mod_wsgi)"
    pre_start_apache_config
    ensure_valid_httpd_process "$HTTPD_PID_FILE" "$HTTPD_CFG_FILE"
    # Force httpd into its own pgroup, as httpd is hard-coded to TERM everything in
    # its pgroup during shutdown (even while foregrounded)
    set -m
    eval "nohup /usr/sbin/httpd $HTTPD_CMD_CONF -DFOREGROUND |& /usr/bin/logshifter -tag python &"
    set +m
    [ "$?" == "0" ] && wait_for_pid_file $HTTPD_PID_FILE
}

function start() {
    if [ -f "${OPENSHIFT_REPO_DIR}app.py" ]; then
        start_app
    else
        start_apache
    fi
}

function stop_app() {
    if [ -s ${OPENSHIFT_PYTHON_DIR}run/appserver.pid ]; then
        kpid=$(cat ${OPENSHIFT_PYTHON_DIR}run/appserver.pid)
        iters=0
        while kill $kpid >/dev/null 2>&1; do
            iters=$(($iters + 1))
            [ $iters -gt 10 ] && break
            sleep 1
        done
        kill -KILL $kpid >/dev/null 2>&1 || :
        rm -f ${OPENSHIFT_PYTHON_DIR}run/appserver.pid
    fi
}

function stop_apache() {
    ensure_valid_httpd_pid_file "$HTTPD_PID_FILE" "$HTTPD_CFG_FILE"
    if [ -f "$HTTPD_PID_FILE" ]; then
        shutdown_httpd_graceful $HTTPD_PID_FILE
    fi
}

function stop() {
    echo "Stopping Python ${OPENSHIFT_PYTHON_VERSION} cartridge"

    # Do both in case the last commit transitioned from one to the
    # other or there was a problem.
    stop_apache
    stop_app
}


function restart() {
    echo "Restarting Python ${OPENSHIFT_PYTHON_VERSION} cartridge"
    if [ -f "${OPENSHIFT_REPO_DIR}app.py" ]; then
        stop_apache
        stop_app
        start_app
    else
        stop_app
        pre_start_apache_config
        ensure_httpd_restart_succeed "$HTTPD_PID_FILE" "$HTTPD_CFG_FILE"
        if [ -f "$HTTPD_PID_FILE" ]; then
          httpd_pid=`cat "$HTTPD_PID_FILE" 2> /dev/null`
          kill -HUP $httpd_pid
        else
          start
        fi
    fi
}

function status() {
    res=0
    if [ -f "${OPENSHIFT_REPO_DIR}app.py" ]; then
        output=$(curl -s -m 30 http://$OPENSHIFT_PYTHON_IP:$OPENSHIFT_PYTHON_PORT/ &> /dev/null) || res=1
    else
        output=$(curl -s -m 30 http://$OPENSHIFT_PYTHON_IP:$OPENSHIFT_PYTHON_PORT/server-status?auto 2>&1 ) || res=1
    fi
    if [ $res -eq 0 ]; then
        client_result "Application is running"
    else
        client_result "Application is either stopped or inaccessible"
    fi
}

# Clean up any log files
function tidy() {
    client_message "Emptying python logs in dir: $OPENSHIFT_LOG_DIR"
    shopt -s dotglob
    rm -rf $OPENSHIFT_LOG_DIR/python.log*
}

function build() {
    if [ -n "$OPENSHIFT_PYPI_MIRROR_URL" ]; then
        m=$OPENSHIFT_PYPI_MIRROR_URL
        if curl -m 15 -f -s "$m" &>/dev/null
        then
            OPENSHIFT_PYTHON_MIRROR="-i $m"
        fi
    fi

    if force_clean_build_enabled_for_latest_deployment; then
        echo "Force-clean builds are enabled" 1>&2
        rm -rf $VIRTUAL_ENV/*
    fi

    if [ ! -f $VIRTUAL_ENV/bin/python ]; then
      echo "Recreating virtenv" 1>&2
      create-virtenv
    fi

    echo "Activating virtenv"
    activate-virtenv

    local requirements_file=${OPENSHIFT_PYTHON_REQUIREMENTS_PATH:-requirements.txt}
    if [ -f ${OPENSHIFT_REPO_DIR}${requirements_file} ]; then
        echo "Checking for pip dependency listed in ${requirements_file} file.."
        ( cd $OPENSHIFT_REPO_DIR; pip install -r ${OPENSHIFT_REPO_DIR}${requirements_file} $OPENSHIFT_PYTHON_MIRROR )
    fi

    if [ -f ${OPENSHIFT_REPO_DIR}/setup.py ]; then
        echo "Running setup.py script.."
        ( cd $OPENSHIFT_REPO_DIR; python ${OPENSHIFT_REPO_DIR}/setup.py develop $OPENSHIFT_PYTHON_MIRROR )
    fi

    relative-virtenv
}

function deploy() {
    relative-virtenv
    activate-virtenv
}

case "$1" in
  start)     start ;;
  stop)      stop ;;
  restart)   restart ;;
  reload)    restart ;;
  status)    status ;;
  tidy)      tidy ;;
  build)     build ;;
  deploy)    deploy ;;
  *)         exit 0
esac
