#
# Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#

SCLOGGER=/usr/cluster/lib/sc/scds_syslog
PKG=SUNWscmqs.trm
METHOD=`basename $0`
DS_TMPDIR=/var/tmp
LOGFILE=${DS_TMPDIR}/${RESOURCE}_logfile
TASK_COMMAND=""
PATTERN="\<$QMGR\>|\<m$QMGR\>"
RESOURCE_PROJECT_NAME=""
SCHA_RESOURCEGROUP_GET=/usr/cluster/bin/scha_resourcegroup_get
SCHA_RESOURCE_GET=/usr/cluster/bin/scha_resource_get
SCHA_CLUSTER_GET=/usr/cluster/bin/scha_cluster_get

syslog_tag()
{
        #
        # Data Service message format
        #

        $SET_DEBUG

        print "SC[${PKG:-??}.${METHOD:-??}]:${RESOURCEGROUP:-??}:${RESOURCE:-??}"
}

scds_syslog()
{

        #
        # Log a message
        #

        $SET_DEBUG

        $SCLOGGER "$@" &
}

debug_message()
{
        #
        # Output a debug message to syslog if required
        #

        if [ "$DEBUG" = "$RESOURCE" -o "$DEBUG" = "ALL" ]
        then
                SET_DEBUG="set -x"

                DEBUG_TEXT=$1

                scds_syslog -p daemon.debug -t $(syslog_tag) -m \
                        "%s" "$DEBUG_TEXT"
        else
                SET_DEBUG=
        fi
}

log_message()
{
        #
        # Output a message to syslog as required
        #

        debug_message "Function: log_message - Begin"
        $SET_DEBUG

        if [ -s "${LOGFILE}" ]
        then
                PRIORITY=$1
                HEADER=$2

                #
                # Ensure the while loop only reads a closed file
                #

                strings ${LOGFILE} > ${LOGFILE}.copy
                while read MSG_TXT
                do
                        scds_syslog -p daemon.${PRIORITY} -t $(syslog_tag) -m \
                                "%s - %s" \
                                "${HEADER}" "${MSG_TXT}"
                done < ${LOGFILE}.copy

                su ${USERID} -c "cat /dev/null > $LOGFILE" > /dev/null
                cat /dev/null > ${LOGFILE}.copy
        fi

        debug_message "Function: log_message - End"
}

validate_options()
{
        #
        # Ensure all options are set
        #

        for i in RESOURCE RESOURCEGROUP QMGR TRIGGER_MONITOR USERID
        do
                case $i in
                        RESOURCE)
                        if [ -z $RESOURCE ]; then
                                logger -p daemon.err \
                                "ERROR: `basename $0` Option -R not set"
                                exit 1
                        fi;;

                        RESOURCEGROUP)
                        if [ -z $RESOURCEGROUP ]; then
                                logger -p daemon.err \
                                "ERROR: `basename $0` Option -G not set"
                                exit 1
                        fi;;

                        QMGR)
                        if [ -z $QMGR ]; then
                                logger -p daemon.err \
                                "ERROR: `basename $0` Option -Q not set"
                                exit 1
                        fi;;

                        TRIGGER_MONITOR)
                        if [ -z $TRIGGER_MONITOR ]; then
                                logger -p daemon.err \
                                "ERROR: `basename $0` Option -M not set"
                                exit 1
                        fi;;

                        USERID)
                        if [ -z $USERID ]; then
				USERID=mqm
                        fi;;

                esac
        done
}

validate()
{
	# 
	# Validate 
	#

        debug_message "Function: validate - Begin"
	$SET_DEBUG

	rc_validate=0

	# 
	# Validate that trm_queues exists
	#

        case $TRIGGER_MONITOR in
                FILE|File|file)
                        if [ ! -f `dirname $0`/../etc/${QMGR}_trm_queues ]
                        then
                                scds_syslog -p daemon.error -t $(syslog_tag) -m \
                                        "Validate - ${QMGR}_trm_queues does not exist"

                                rc_validate=1
                        else
                                debug_message "Validate - ${QMGR}_trm_queues exists"
                        fi ;;
                *)
                        continue;;
        esac

        debug_message "Function: validate - End"
}
	
check_qmgr()
{
        #
        # Check if Queue Manager is running
        #

        debug_message "Function: check_qmgr - Begin"
	$SET_DEBUG

        rc_check_qmgr_pids=
        flag=

        while [ "$rc_check_qmgr_pids" != 000 ]
        do
                rc_check_qmgr_pids=
                sleep 1

                # Here we simply check for the main processes

                for pid in amqzxma0 amqhasmx amqzllp0
                do
			if ps -u mqm -o pid,args | eval /usr/xpg4/bin/grep -E '$PATTERN' |\
				grep -w $pid > /dev/null
                        then
                                rc=0
                        else
                                if [ "$flag" ]
                                then
                                        rc=1
                                else
                                        flag=set

                                        scds_syslog -p daemon.notice -t $(syslog_tag) -m \
                                        	"Waiting for WebSphere MQ Queue Manager"
				
                                        rc=1
                                fi
                        fi

                        rc_check_qmgr_pids=$rc_check_qmgr_pids$rc
                done
        done

	rc_check_qmgr=1

	while [ "$rc_check_qmgr" != 0 ]
	do
		sleep 5

        	hatimerun -k KILL -t 5 echo "ping qmgr" | runmqsc ${QMGR} > /dev/null 2>&1
        	rc_check_qmgr=$?
	done

        scds_syslog -p daemon.notice -t $(syslog_tag) -m \
		"WebSphere MQ Queue Manager available"

        debug_message "Function: check_qmgr - End"
}

start_trm()
{
	# 
	# Start the Trigger Monitor
	#

        debug_message "Function: start_trm - Begin"
        $SET_DEBUG

	TRMQ=$1

	srm_function ${USERID}

        if getent passwd ${USERID} | awk -F: '{print $7}' | grep csh > /dev/null
        then
                su - ${USERID} -c "$TASK_COMMAND nohup runmqtrm -m ${QMGR} -q ${TRMQ} >& $LOGFILE &" > /dev/null
        else
                su - ${USERID} -c "$TASK_COMMAND nohup runmqtrm -m ${QMGR} -q ${TRMQ} > $LOGFILE 2>&1 &" > /dev/null
        fi

        # Just allow some time for the command to run, ie output to $LOGFILE
        sleep 1

        scds_syslog -p daemon.notice -t $(syslog_tag) -m \
        	"WebSphere MQ Trigger Monitor %s started" \
        	"${TRMQ}"

        debug_message "Function: start_trm - End"
}

start_trm_from_test ()
{
	# 
	# Start the Trigger Monitor  from test-trm 
	#

        debug_message "Function: start_trm_from_test - Begin"
	$SET_DEBUG

	TRMQ=$1
	
	srm_function ${USERID}

	if ps -u mqm -o pid,args | eval /usr/xpg4/bin/grep -E '$PATTERN' |\
		grep -w $TRMQ > /dev/null
	then
		continue
	else
		if getent passwd ${USERID} | awk -F: '{print $7}' | grep csh > /dev/null
		then
			su - ${USERID} -c "$TASK_COMMAND nohup runmqtrm -m ${QMGR} -q ${TRMQ} >& $LOGFILE &" > /dev/null
		else
			su - ${USERID} -c "$TASK_COMMAND nohup runmqtrm -m ${QMGR} -q ${TRMQ} > $LOGFILE 2>&1 &" > /dev/null
		fi
			
        	# Just allow some time for the command to run, ie output to $LOGFILE
        	sleep 1
			
		scds_syslog -p daemon.notice -t $(syslog_tag) -m \
			"WebSphere MQ Trigger Monitor %s restarted" \
			"${TRMQ}"
	fi

        debug_message "Function: start_trm_from_test - End"
}

stop_trm()
{
        #
        # Stop the Trigger Monitor
        #

        debug_message "Function: stop_trm - Begin"
        $SET_DEBUG

	TRMQ=$1

        pkill -9 -f -u mqm "runmqtrm -m ${QMGR} -q ${TRMQ}"

        scds_syslog -p daemon.notice -t $(syslog_tag) -m \
        	"WebSphere MQ Trigger Monitor %s stopped" \
        	"${TRMQ}"

        debug_message "Function: stop_trm - End"
}

check_pmftag()
{
	# 
	# Check the pmftag exists
	#
	
        debug_message "Function: check_pmftag - Begin"
	$SET_DEBUG

	hatimerun -k KILL -t 10 pmfadm -q $RESOURCEGROUP,$RESOURCE,0.svc

	rc_check_pmftag=$?

        debug_message "Function: check_pmftag - End"
}

check_state()
{
	# 
	# Check the resource state
	#
	
        debug_message "Function: check_state - Begin"
	$SET_DEBUG

	STATE=`hatimerun -k KILL -t 10 scha_resource_get \
        	-O RESOURCE_STATE -G $RESOURCEGROUP -R $RESOURCE`
	
	rc_check_state=$?

	status=`hatimerun -k KILL -t 10 scha_resource_get \
        	-O STATUS -G $RESOURCEGROUP -R $RESOURCE`

	rc_check_status=$?

	STATUS=`echo $status | awk '{print $1}'`

	rc_check_state="$rc_check_state$rc_check_status"
	STATE="$STATE$STATUS"

        debug_message "Function: check_state - End"
}

set_status()
{
        #
        # Set appropriate resource status
        #

        debug_message "Function: set_status - Begin"
	$SET_DEBUG

        STATUS_TYPE=$1

        scha_resource_setstatus -R $RESOURCE -G $RESOURCEGROUP -s $STATUS_TYPE

        rc_scha_resource_setstatus=$?

        if [ "$rc_scha_resource_setstatus" != 0 ]
        then
		scds_syslog -p daemon.error -t $(syslog_tag) -m \
		"set_status - rc<%s> type<%s>" \
		"${rc_scha_resource_setstatus}" "${STATUS_TYPE}"
        fi
	
        debug_message "Function: set_status - End"
}

standard_resource_get()
{
        debug_message "Function: standard_resource_get - Begin"
        $SET_DEBUG

        PROPERTY=$1

        ${SCHA_RESOURCE_GET} -R ${RESOURCE} -G ${RESOURCEGROUP} -O ${PROPERTY}

        s1=$?

        if [ "${s1}" -ne 0 ]; then
                debug_message "standard_resource_get - Get property ${PROPERTY} rc<${s1}>, ignore if SC3.0"
        fi

        debug_message "Function: standard_resource_get - End"
        return ${s1}
}

standard_resourcegroup_get()
{
        debug_message "Function: standard_resourcegroup_get - Begin"
        $SET_DEBUG

        PROPERTY=$1

        ${SCHA_RESOURCEGROUP_GET} -R ${RESOURCE} -G ${RESOURCEGROUP} -O ${PROPERTY}

        s1=$?

        if [ "${s1}" -ne 0 ]; then
                debug_message "standard_resource_get - Get property ${PROPERTY} rc<${s1}>, ignore if SC3.0"
        fi

        debug_message "Function: standard_resourcegroup_get - End"

        return ${s1}
}

srm_function()
{
        debug_message "Function: srm_function - Begin"
        $SET_DEBUG

        USER=$1
   
        # 
        # If Solaris 8 just return
        #

        if [ `/usr/bin/uname -r` = "5.8" ];
        then
                return 0
        fi

        #
        # Retrieve RESOURCE_PROJECT_NAME
        #

        RESOURCE_PROJECT_NAME=`standard_resource_get RESOURCE_PROJECT_NAME`

        #
        # Retrieve RG_PROJECT_NAME if RESOURCE_PROJECT_NAME is not set
        #

        if [ -z "${RESOURCE_PROJECT_NAME}" ]; then

                RESOURCE_PROJECT_NAME=`standard_resourcegroup_get RG_PROJECT_NAME`
        fi

        #
        # Return if no projects are defined
        #

        if [ -z "${RESOURCE_PROJECT_NAME}" ]; then
                return 0
        fi

        #
        # Validate that $USER belongs to the project defined by
        # ${RESOURCE_PROJECT_NAME}
        #

        PROJ_MEMBER=`/usr/bin/projects ${USER} | /usr/bin/grep -w ${RESOURCE_PROJECT_NAME}`

        if [ -z "${PROJ_MEMBER}" ];
        then
             scds_syslog -p daemon.error -t $(syslog_tag) -m \
                        "Validate - The user %s does not belongs to project %s" \
                        "${USER}" "${RESOURCE_PROJECT_NAME}" \
                return 1
        else
                debug_message "srm_function - User ${USER} belongs to project ${RESOURCE_PROJECT_NAME}"
        fi

        #
        # Set TASK_COMMAND
        #

        TASK_COMMAND="/usr/bin/newtask -p ${RESOURCE_PROJECT_NAME}"

        debug_message "Function: srm_function - End"

        return 0
}


