#!/bin/sh
#
##############################
# ctdb:                        Starts the clustered tdb daemon
#
# chkconfig:           - 90 36
#
# description:                 Starts and stops the clustered tdb daemon
# pidfile:             /var/run/ctdbd/ctdbd.pid
#

### BEGIN INIT INFO
# Provides:          ctdb
# Required-Start:    $network $local_fs $remote_fs
# Required-Stop:     $network $local_fs $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: start and stop ctdb service
# Description:       initscript for the ctdb service
### END INIT INFO


PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

NAME=ctdb
DESC="Clustered TDB"

#LSB
if [ -f /lib/lsb/init-functions ] ; then
  . /lib/lsb/init-functions
fi
if ! type 'log_daemon_msg' >/dev/null; then
    log_daemon_msg () {
        if [ -z "${1:-}" ]; then
            return 1
        fi

        if [ -z "${2:-}" ]; then
            echo -n "$1:"
            return
        fi
        
        echo -n "$1: $2"
    }
fi
if ! type 'log_progress_msg' >/dev/null; then
    log_progress_msg () {
        if [ -z "${1:-}" ]; then
            return 1
        fi
        echo -n " $@"
    }
fi
if ! type 'log_end_msg' >/dev/null; then
    log_end_msg () {
        # If no arguments were passed, return
        if [ -z "${1:-}" ]; then
            return 1
        fi

        retval=$1

        if [ $1 -eq 0 ]; then
            echo "."
        elif [ $1 -eq 255 ]; then
            /bin/echo -e " (warning)."
        else
            /bin/echo -e " failed!"
        fi
        return $retval
    }
fi

# Source function library.
if [ -f /etc/init.d/functions ] ; then
    . /etc/init.d/functions
elif [ -f /etc/rc.d/init.d/functions ] ; then
    . /etc/rc.d/init.d/functions
fi

#gettext
if [ -f /usr/bin/gettext.sh ] ; then
    . /usr/bin/gettext.sh
fi
if ! type 'eval_gettext' >/dev/null; then
    eval_gettext() {
        echo -n "$1" | (export PATH `envsubst --variables "$1"`; envsubst "$1")
    }
fi

[ -f /etc/rc.status ] && {
    . /etc/rc.status
    rc_reset
    LC_ALL=en_US.UTF-8
}

# Avoid using root's TMPDIR
unset TMPDIR

[ -z "$CTDB_BASE" ] && {
    export CTDB_BASE="/etc/ctdb"
}

. $CTDB_BASE/functions
loadconfig network
loadconfig ctdb

set -e

# check networking is up (for redhat)
[ "$NETWORKING" = "no" ] && exit 0

detect_init_style
export CTDB_INIT_STYLE

ctdbd=${CTDBD:-/usr/sbin/ctdbd}

test -x $ctdbd || exit 0

if [ "$CTDB_VALGRIND" = "yes" ]; then
    init_style="valgrind"
else
    init_style="$CTDB_INIT_STYLE"
fi

build_ctdb_options () {
    [ -z "$CTDB_RECOVERY_LOCK" ] && {
        echo "You must configure the location of the CTDB_RECOVERY_LOCK"
        exit 1
    }

    maybe_set () {
        # If the 2nd arg is null then return - don't set anything.
        # Else if the 3rd arg is set and it doesn't match the 2nd arg
        # then return
        [ -z "$2" -o \( -n "$3" -a "$3" != "$2" \) ] && return

        val="$2"
        case "$1" in
            --*) sep="=" ;;
            -*)  sep=" " ;;
        esac
        # For these options we're only passing a value-less flag.
        [ -n "$3" ] && {
            val=""
            sep=""
        }

        CTDB_OPTIONS="${CTDB_OPTIONS}${CTDB_OPTIONS:+ }${1}${sep}${val}"
    }

    [ -z "$CTDB_RECOVERY_LOCK" ] && {
        echo "No recovery lock specified. Starting CTDB without split brain prevention"
    }
    maybe_set "--reclock"                "$CTDB_RECOVERY_LOCK"

    # build up CTDB_OPTIONS variable from optional parameters
    maybe_set "--logfile"                "$CTDB_LOGFILE"
    maybe_set "--nlist"                  "$CTDB_NODES"
    maybe_set "--socket"                 "$CTDB_SOCKET"
    maybe_set "--public-addresses"       "$CTDB_PUBLIC_ADDRESSES"
    maybe_set "--public-interface"       "$CTDB_PUBLIC_INTERFACE"
    maybe_set "--dbdir"                  "$CTDB_DBDIR"
    maybe_set "--dbdir-persistent"       "$CTDB_DBDIR_PERSISTENT"
    maybe_set "--event-script-dir"       "$CTDB_EVENT_SCRIPT_DIR"
    maybe_set "--transport"              "$CTDB_TRANSPORT"
    maybe_set "-d"                       "$CTDB_DEBUGLEVEL"
    maybe_set "--notification-script"    "$CTDB_NOTIFY_SCRIPT"
    maybe_set "--start-as-disabled"      "$CTDB_START_AS_DISABLED"    "yes"
    maybe_set "--start-as-stopped "      "$CTDB_START_AS_STOPPED"     "yes"
    maybe_set "--no-recmaster"           "$CTDB_CAPABILITY_RECMASTER" "no"
    maybe_set "--no-lmaster"             "$CTDB_CAPABILITY_LMASTER"   "no"
    maybe_set "--lvs --single-public-ip" "$CTDB_LVS_PUBLIC_IP"
    maybe_set "--script-log-level"       "$CTDB_SCRIPT_LOG_LEVEL"
}

check_persistent_databases () {
    case $init_style in
        debian) PERSISTENT_DB_DIR="${CTDB_DBDIR:-/var/lib/ctdb}/persistent" ;;
        *) PERSISTENT_DB_DIR="${CTDB_DBDIR:-/var/ctdb}/persistent" ;;
    esac
    mkdir -p $PERSISTENT_DB_DIR 2>/dev/null
    for PDBASE in `ls $PERSISTENT_DB_DIR/*.tdb.[0-9] 2>/dev/null`; do
        /usr/bin/tdbdump $PDBASE >/dev/null 2>/dev/null || {
        echo "Persistent database $PDBASE is corrupted! CTDB will not start."
        return 1
    }
    done
}

set_ctdb_variables () {
    # set any tunables from the config file
    set | grep ^CTDB_SET_ | cut -d_ -f3- | 
    while read v; do
        varname=`echo $v | cut -d= -f1`
        value=`echo $v | cut -d= -f2`
        ctdb setvar $varname $value || RETVAL=1
    done || exit 1
}

set_retval() {
    return $1
}

running() {
    pkill -0 -f $ctdbd || return 1
    return 0
}

start_server() {
    build_ctdb_options

    check_persistent_databases || return $?

    if [ yes == "$CTDB_SUPPRESS_COREFILE" ]; then
	ulimit -c 0
    else
	ulimit -c unlimited
    fi

    case $init_style in
        valgrind)
	        valgrind -q --log-file=/var/log/ctdb_valgrind \
	            $ctdbd --nosetsched $CTDB_OPTIONS 
	        RETVAL=$?
	        echo
	    ;;
        suse)
	        startproc $ctdbd $CTDB_OPTIONS
	        rc_status -v
	        RETVAL=$?
	    ;;
        redhat)
	        daemon $ctdbd $CTDB_OPTIONS
	        RETVAL=$?
	        echo
	        [ $RETVAL -eq 0 ] && touch /var/lock/subsys/ctdb || RETVAL=1
	    ;;
        debian)
	        start-stop-daemon --start --quiet --background \
	            --exec $ctdbd -- $CTDB_OPTIONS
	        RETVAL=$?
	    ;;
    esac

    sleep 1

    set_ctdb_variables

    return $RETVAL
}	

stop_server() {
    ctdb shutdown >/dev/null 2>&1
    RETVAL=$?
    count=0
    if [ "$init_style" = "debian" ]; then
        start-stop-daemon --stop --quiet --exec $ctdbd
        RETVAL=$?
    fi
    while pkill -0 -f $ctdbd ; do
        sleep 1
        count=`expr $count + 1`
        [ $count -gt 10 ] && {
	        eval_gettext "killing ctdbd "
	        pkill -9 -f $ctdbd
	        pkill -9 -f $CTDB_BASE/events.d/
        }
    done
    case $init_style in
        suse)
	        # re-set the return code to the recorded RETVAL in order
	        # to print the correct status message
	        set_retval $RETVAL
	        rc_status -v
	    ;;
        redhat)
	        [ $RETVAL -eq 0 ] && success || failure
	        [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/ctdb
	        echo ""
	    ;;
    esac
    return $RETVAL
}	

case "$1" in
    start)
        log_daemon_msg "Starting $DESC " "$NAME"
        # Check if it's running first
        if running ;  then
            log_progress_msg "already running"
            log_end_msg 0
            exit 0
        fi
        if start_server && running ;  then
            # It's ok, the server started and is running
            log_end_msg 0
        else
            # Either we could not start it or it is not running
            # after we did
            log_end_msg 1
        fi
        ;;
    stop)
        log_daemon_msg "Stopping $DESC" "$NAME"
        if running ; then
            # Only stop the server if we see it running
            stop_server
            log_end_msg $?
        else
            # If it's not running don't do anything
            log_progress_msg "not running"
            log_end_msg 0
            exit 0
        fi
        ;;
    restart|reload|force-reload)
        log_daemon_msg "Restarting $DESC" "$NAME"
        running && stop_server
        start_server
        running
        log_end_msg $?
        ;;
    status)
        log_daemon_msg "Checking status of $DESC" "$NAME"
        if running ;  then
            log_progress_msg "running"
            echo
            ctdb status
            log_end_msg 0
        else
            log_progress_msg "not running"
            log_end_msg 1
            exit 1
        fi
 	    ;;
    condrestart)
        if running ;  then
            log_daemon_msg "Restarting $DESC" "$NAME"
            stop_server
            start_server
            log_end_msg $?
        fi
        ;;
    cron)
        # used from cron to auto-restart ctdb
        if ! running ; then
            log_daemon_msg "Starting $DESC " "$NAME"
            if start_server && running ;  then
                # It's ok, the server started and is running
                log_end_msg 0
            else
                # Either we could not start it or it is not running
                # after we did
                log_end_msg 1
            fi
        fi
        ;;
    *)
        eval_gettext "Usage: $0 {start|stop|restart|status|cron|condrestart}" >&2
        echo >&2
        exit 1
        ;;
esac

exit $?