#! /bin/bash
#
# BDII system startup script
# $Id: bdii,v 1.9 2009/06/18 14:26:52 lfield Exp $
# chkconfig: 345 95 5
# description: BDII Service
# config: /opt/bdii/etc/bdii.conf

### BEGIN INIT INFO
# Provides:          bdii
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     3 4 5
# Default-Stop:      0 1 2 6
# Short-Description: BDII
# Description:       Berkeley Database Information Index
### END INIT INFO

shopt -s expand_aliases

if [ -f /lib/lsb/init-functions ]; then
    . /lib/lsb/init-functions
else
    echo "Error: Cannot source /lib/lsb/init-functions"
fi

prog=bdii
lockfile=/var/lock/subsys/$prog

RUN=yes

if [ -r /etc/default/bdii ] ; then
    . /etc/default/bdii
fi
if [ -r /etc/sysconfig/bdii ] ; then
    . /etc/sysconfig/bdii
fi

if [ "x$RUN" != "xyes" ] ; then
    echo "bdii disabled, please adjust the configuration to your needs "
    echo "and then set RUN to 'yes' in /etc/default/bdii to enable it."
    exit 0
fi

BDII_CONF=${BDII_CONF:-/etc/bdii/bdii.conf}

if [ -f "${BDII_CONF}" ]; then
    . "${BDII_CONF}"
fi

UPDATE_LOCK_FILE=${UPDATE_LOCK_FILE:-/var/lock/subsys/bdii-update}
SLAPD_LOCK_FILE=${SLAPD_LOCK_FILE:-/var/lock/subsys/bdii-slapd}
UPDATE_PID_FILE=${PID_FILE:-/var/run/bdii-update.pid}
BDII_USER=${BDII_USER:-ldap}
BDII_VAR_DIR=${BDII_VAR_DIR:-/var/run/bdii}
BDII_UPDATE=${BDII_UPDATE:-/usr/sbin/bdii-update}
BDII_PROXY=${BDII_PROXY:-/usr/sbin/bdii-proxy}
SLAPD=${SLAPD:-/usr/sbin/slapd}
SLAPD_CONF=${SLAPD_CONF:-/etc/bdii/bdii-slapd.conf}
SLAPD_HOST=${SLAPD_HOST:-0.0.0.0}
SLAPD_PORT=${SLAPD_PORT:-2170}
SLAPD_DB_DIR=${SLAPD_DB_DIR:-$BDII_VAR_DIR/db}
SLAPD_PID_FILE=${SLAPD_PID_FILE:-$SLAPD_DB_DIR/slapd.pid}
DB_CONFIG=${DB_CONFIG:-/etc/bdii/DB_CONFIG}

if [ -x /sbin/runuser ] ; then
    RUNUSER=runuser
else
    RUNUSER=su
fi

function start(){

    # Check status
    if [ -f "${SLAPD_LOCK_FILE}" ] || [ -f "${UPDATE_LOCK_FILE}" ] ; then
        echo -n "Starting BDII: "
        result=$($0 status)
        if [ $? -gt 0 ]; then
            echo ${result} 1>&2
            exit 1
        else
            echo "BDII already started"
            exit 0
        fi
    fi

    # Create proxy
    ${BDII_PROXY} ${BDII_CONF}

    # Create RAM Disk
    if [ "${BDII_RAM_DISK}" = "yes" ]; then
	mount -t tmpfs -o size=1500M,mode=0744 tmpfs ${SLAPD_DB_DIR}
    fi

    #Initialize the database directory.
    mkdir -p ${SLAPD_DB_DIR}/stats
    mkdir -p ${SLAPD_DB_DIR}/glue2
    mkdir -p ${BDII_VAR_DIR}/archive
    mkdir -p /var/lock/subsys
    chown -R ${BDII_USER}:${BDII_USER} ${BDII_VAR_DIR}
    [ -x /sbin/restorecon ] && /sbin/restorecon -R ${BDII_VAR_DIR}
    chown -R ${BDII_USER}:${BDII_USER} ${SLAPD_DB_DIR}
    $RUNUSER -s /bin/sh ${BDII_USER} -c "rm -f ${SLAPD_DB_DIR}/stats/* 2>/dev/null"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "rm -f ${SLAPD_DB_DIR}/glue2/* 2>/dev/null"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "rm -f ${SLAPD_DB_DIR}/* 2>/dev/null"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "rm -f ${BDII_VAR_DIR}/old.ldif 2>/dev/null"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "cp ${DB_CONFIG} ${SLAPD_DB_DIR}"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "cp ${DB_CONFIG} ${SLAPD_DB_DIR}/stats/"
    $RUNUSER -s /bin/sh ${BDII_USER} -c "cp ${DB_CONFIG} ${SLAPD_DB_DIR}/glue2/"
 

    echo -n "Starting BDII slapd: "
    COMMAND="${SLAPD} -f ${SLAPD_CONF} -h ldap://${SLAPD_HOST}:${SLAPD_PORT} -u ${BDII_USER}"
    ${COMMAND}
    touch ${SLAPD_LOCK_FILE}
    if [ ! -f "${SLAPD_PID_FILE}" ]; then
        sleep 2
    fi

    if [ -f "${SLAPD_PID_FILE}" ]; then
        ps $(cat ${SLAPD_PID_FILE}) >/dev/null 2>&1
        RETVAL=$?
    else
        RETVAL=1
    fi

    if [ ${RETVAL} -gt 0 ]; then
        echo -n "BDII slapd failed to start" 1>&2

        rm -f ${SLAPD_LOCK_FILE}
        eval log_failure_msg
        echo "${COMMAND} -d 256"
        ${COMMAND} -d 256
        return 1
    else
        eval log_success_msg
    fi

    export SLAPD_CONF=${SLAPD_CONF}
    $RUNUSER -s /bin/sh ${BDII_USER} -c "${BDII_UPDATE} -c ${BDII_CONF} -d"
    touch ${UPDATE_LOCK_FILE}

    if [ ! -f ${BDII_VAR_DIR}/bdii-update.pid ]; then
        sleep 2
    fi
    if [ -f ${BDII_VAR_DIR}/bdii-update.pid ]; then
        touch ${UPDATE_PID_FILE}
        chown ${BDII_USER} ${UPDATE_PID_FILE}
        mv ${BDII_VAR_DIR}/bdii-update.pid ${UPDATE_PID_FILE}
        ps $(cat ${UPDATE_PID_FILE}) >/dev/null 2>&1
        RETVAL=$?
    else
        RETVAL=1
    fi

    echo -n "Starting BDII update process: "
    if [ ${RETVAL} -gt 0 ]; then
        echo -n "BDII update process failed to start" 1>&2
        rm -f ${UPDATE_LOCK_FILE}
        eval log_failure_msg
        return 1
    else
        eval log_success_msg
        touch $lockfile
        return 0
    fi
}

function stop(){

    # Check the existance of the lock file
    if [ ! -f "${SLAPD_LOCK_FILE}" ] &&  [ ! -f "${UPDATE_LOCK_FILE}" ]; then
        echo -n "Stopping BDII: "
        result=$($0 status)
        if [ $? -gt 0 -a $? -ne 3 ]; then
            echo ${result} 1>&2
            return 1
        else
            echo "BDII already stopped"
            return 0
        fi
    fi

    RETVAL=0

    echo -n "Stopping BDII update process: "

    if [ -f "${UPDATE_PID_FILE}" ]; then
        UPDATE_PID=$(cat ${UPDATE_PID_FILE})
    fi

    $RUNUSER -s /bin/sh ${BDII_USER} -c "kill -15 ${UPDATE_PID} 2>/dev/null"
    if [ -n "${UPDATE_PID}" ]; then
        ps ${UPDATE_PID} >/dev/null 2>&1
        if [ $? = 0 ]; then
            sleep 2
            ps ${UPDATE_PID} >/dev/null 2>&1
            if [ $? = 0 ]; then
                $RUNUSER -s /bin/sh ${BDII_USER} -c "kill -9 ${UPDATE_PID} 2>/dev/null"
                sleep 2
                ps ${UPDATE_PID} >/dev/null 2>&1
                if [ $? = 0 ]; then
                    echo -n "Could not kill BDII update process ${UPDATE_PID}" 1>&2
                    RETVAL=1
                fi
            fi
        fi
    fi

    if [ ${RETVAL} = 0 ];  then
        rm -f ${UPDATE_PID_FILE}
        rm -f ${UPDATE_LOCK_FILE}
        eval log_success_msg
    else
        eval log_failure_msg
    fi

    echo -n "Stopping BDII slapd: "

    if [ -f "${SLAPD_PID_FILE}" ]; then
        SLAPD_PID=$(cat ${SLAPD_PID_FILE})
    fi

    $RUNUSER -s /bin/sh ${BDII_USER} -c "kill -15 ${SLAPD_PID} 2>/dev/null"
    if [ -n "${SLAPD_PID}" ]; then
        ps ${SLAPD_PID} >/dev/null 2>&1
        if [ $? = 0 ]; then
            sleep 2
            ps ${SLAPD_PID} >/dev/null 2>&1
            if [ $? = 0 ]; then
                $RUNUSER -s /bin/sh ${BDII_USER} -c "kill -9 ${SLAPD_PID} 2>/dev/null"
                sleep 2
                ps ${SLAPD_PID} >/dev/null 2>&1
                if [ $? = 0 ]; then
                    echo -n "Could not kill BDII slapd process ${SLAPD_PID}" 1>&2
                    RETVAL=2
                else
                    rm -f {SLAPD_PID_FILE}
                fi
            fi
        fi
    fi

    
    if [ ${RETVAL} = 2 ];  then
        eval log_failure_msg
    else
        rm -f ${SLAPD_LOCK_FILE}
        eval log_success_msg
    fi

    if [ ! ${RETVAL} = 0 ];  then
        return 1
    else
	mountpoint -q ${SLAPD_DB_DIR} && umount ${SLAPD_DB_DIR}
        rm -f $lockfile
        return 0
    fi
}

function status(){

    if [ ! -f "${SLAPD_LOCK_FILE}" ] && [ ! -f "${UPDATE_LOCK_FILE}" ]; then
        echo -n "BDII Stopped"
        eval log_success_msg
        return 3
    fi

    if [ -f ${SLAPD_PID_FILE} ]; then
        ps $(cat ${SLAPD_PID_FILE}) >/dev/null 2>&1
        if [ ! $? = 0 ]; then
            echo -n "BDII slapd PID file exists but the process died" 1>&2
            eval log_failure_msg
            return 1
        fi
    else
        echo -n "BDII slapd PID file ${SLAPD_PID_FILE} does not exist" 1>&2
        eval log_failure_msg
        return 1
    fi

    if [ -f ${UPDATE_PID_FILE} ]; then
        ps $(cat ${UPDATE_PID_FILE}) >/dev/null 2>&1
        if [ ! $? = 0 ]; then
            echo -n "BDII update process died" 1>&2
            eval log_failure_msg
            return 1
        fi
    else
        echo -n "BDII update process failed to start" 1>&2
        eval log_failure_msg
        return 1
    fi

    echo -n "BDII Runnning "
    eval log_success_msg
    return 0
}

case "$1" in
    start)
        start
        RETVAL=$?
        ;;
    stop)
        stop
        RETVAL=$?
        ;;
    status)
        status
        RETVAL=$?
        ;;
    reload)
        ;;
    restart | force-reload)
        stop
        start
        RETVAL=$?
        ;;
    condrestart | try-restart)
        if [ -f ${SLAPD_LOCK_FILE} ] || [ -f ${UPDATE_LOCK_FILE} ]; then
            stop
            start
            RETVAL=$?
        fi
        ;;
    *)
        echo $"Usage: $0 {start|stop|restart|status|condrestart}"
        RETVAL=1
esac

exit ${RETVAL}
