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

SCLOGGER=/usr/cluster/lib/sc/scds_syslog
PKG=SUNWscswa
METHOD=`basename $0`
LOGFILE=/var/tmp/${RESOURCE}_logfile

CAP2LOW='/bin/tr "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"'
LOW2CAP='/bin/tr "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"'
SCHA_RESOURCE_GET=/usr/cluster/bin/scha_resource_get
SCHA_RESOURCEGROUP_GET=/usr/cluster/bin/scha_resourcegroup_get
HATIMERUN=/usr/cluster/bin/hatimerun

# LIB LOGICALHOST

LIB64=libsclogicalhost_64.so.1
LIB32=libsclogicalhost_32.so.1
LIBSEC32=/usr/lib/secure/32
LIBSEC64=/usr/lib/secure/64
DEFLIB=`/bin/dirname $0`/../lib

# JAVA PROBE

JAVA_PROBE=`/bin/dirname $0`/sap_j2ee_probe

TASK_COMMAND=""
RESOURCE_PROJECT_NAME=""
ENV=""

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
}

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

         s1=1
         s2=`echo $1 | /bin/wc -c`
         s3=""

        while [ $s1 -lt ${s2} ]
        do

                s4=`echo $1 | /bin/cut -c ${s1}`

                if [[ "${s4}" == @([0-9]) ]]; then
                	s3=${s3}${s4}
                fi

                s1=$(($s1+1))

        done

        echo $s3

  debug_message "Function: stripfunc - End"
}


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

  DUMMY_PROCESS="/tmp/${RESOURCE}_${RESOURCEGROUP}_dummy.csh"

  cat > ${DUMMY_PROCESS} <<EOF
#!/bin/csh

while (1)
	sleep 3600
end
EOF

  /bin/chmod 755 ${DUMMY_PROCESS}

  ${DUMMY_PROCESS} &

  debug_message "Function: create_dummy_process - End"
  return
}

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 - Retrievment of property ${PROPERTY} returned ${s1}"
	fi

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

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

	PROPERTY=$1

	${SCHA_RESOURCE_GET} -R ${RESOURCE} -G ${RESOURCEGROUP} -O EXTENSION ${PROPERTY} | /bin/tail -1

	s1=$?

	if [ "${s1}" -ne 0 ]; then
		debug_message "extension_resource_get - Retrievment of extension property ${PROPERTY} returned ${s1}"
	fi

        debug_message "Function: extension_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 - Retrievment of property ${PROPERTY} returned ${s1}"
	fi

        debug_message "Function: standard_resourcegroup_get - End"

	return ${s1}
}

srm_function()
{

	USER=$1

        debug_message "Function: srm_function - Begin"
        $SET_DEBUG

   
	# 
	# 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 \
                        "srm_function - 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
}

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

        for i in RESOURCE RESOURCEGROUP JAVA_HOME SAPID SAP_J2EE_INSTANCIES LHOSTNAME SAP_START SAP_STOP

        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;;

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

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

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


                        LHOSTNAME)
			if [ -z $LHOSTNAME ]; then
			#  Set LHOSTNAME as Physical Hostname for scalable feature which
			#  will do probe based on physical hostname  
                       		LHOSTNAME=`/usr/bin/hostname`
        			debug_message "set LHOSTNAME=${LHOSTNAME}"
            		fi;;
                esac
        done
}

validate() 
{
	#
	# Validate SAP J2EE 
	#
        debug_message "Function: validate - Begin"
	$SET_DEBUG

	#
	# Validate that this cluster version support
	# Inter-RG dependencies 
	#

        #Prop=`standard_resource_get RESOURCE_DEPENDENCIES_RESTART`
        #s1=$?

	#if [ "${s1}" -ne 0 ];
	#then
   		#scds_syslog -p daemon.error -t $(syslog_tag) -m \
			#"Validate - This cluster version does not support Inter-RG dependencies" 
		#return 1
	#else
		#debug_message "Validate - This cluster version support Inter-RG dependencies"
	#fi


	#
	# Get <sapid>adm user
	#

	SAP_USER="`echo ${SAPID} | $CAP2LOW`"adm


	#
	# Validate $SAPUSER
	#

	if [ -z "`/bin/getent passwd ${SAP_USER}`" ];
	then
   		scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - The sap user %s does not exist" \
			"${SAPUSER}"
		return 1
	else
		debug_message "Validate - Sap user ${SAP_USER} exists" 
	fi

	#
	# Extract and verfiy $SAP_USER home directory
	#

	SAP_USER_HOME=`/bin/getent passwd ${SAP_USER} | /bin/cut -d: -f6`

	if [ -z "${SAP_USER_HOME} -o ! -d "${SAP_USER_HOME} ];
	then
   		scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - The Sap user %s home-directory %s does not exist" \
			"${SAP_USER}" "${SAP_USER_HOME}"
		return 1
	else
		debug_message "Validate - The Sap user ${SAP_USER} home-directory ${SAP_USER_HOME} exists"
	fi

	#
	# Validate ${sapid}
	#

	SAPID="`echo ${SAPID} | $LOW2CAP`"

	if [ ! -d "/usr/sap/${SAPID}" ]; then
   		scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - The Sap id %s is invalid" \
			"${SAPID}"
		return 1
	else
		debug_message "Validate - The Sap id ${SAPID} is valid"
	fi

	#
	# Validate SAP J2EE instancies
	#

        for j2ee_instance in `echo ${SAP_J2EE_INSTANCIES} | tr '+' ' '`
        do
	   s1=`echo /usr/sap/${SAPID}/SYS/profile/START_${j2ee_instance}_${LHOSTNAME}`
           for profile in `echo ${s1} | tr '+' ' '`
           do
	   	if [ ! -f "${profile}" ];
	   	then
   			scds_syslog -p daemon.error -t $(syslog_tag) -m \
				"Validate - The profile for SAP J2EE instance %s does not exist" \
				"${j2ee_instance}"
			return 1
	   	else
			debug_message "Validate - The profile for SAP J2EE instance ${j2ee_instance} exist"
	   	fi
	   done

	done


	#
	# Validate JAVA_HOME
	#

	if [ ! -x "${JAVA_HOME}/bin/java" ];
	then
   		scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - %s could not be found" \
			"${JAVA_HOME}/bin/java"
		return 1
	else
		debug_message "Validate - ${JAVA_HOME}/bin/java exists"
	fi

	#
	# Validate SAP_START if defined
	#

	if [ ! -z "${SAP_START}" ];
	then

		if [ ! -x "${SAP_USER_HOME}/${SAP_START}" ];
		then
   			scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - %s is non-existent or non-executable" \
			"${SAP_USER_HOME}/${SAP_START}"
			return 1
		else
			debug_message "Validate - ${SAP_USER_HOME}/${SAP_START} exists and is executable"
		fi
	fi
	
	#
	# Validate SAP_STOP if defined
	#

	if [ ! -z "${SAP_STOP}" ];
	then

		if [ ! -x "${SAP_USER_HOME}/${SAP_STOP}" ];
		then
   			scds_syslog -p daemon.error -t $(syslog_tag) -m \
			"Validate - %s is non-existent or non-executable" \
			"${SAP_USER_HOME}/${SAP_STOP}"
			return 1
		else
			debug_message "Validate - ${SAP_USER_HOME}/${SAP_STOP} exists and is executable"
		fi
	fi


	#
	# Validate and set SRM projects
	#

	srm_function $SAP_USER
	ret=$?

	if [ "${ret}" -ne 0 ]; then
          return 1
	fi

        #
        # Validate SAP_LOGDIR if defined
        #

        if [ ! -z "${SAP_LOGDIR}"    ]; then

                if [ ! -d "${SAP_LOGDIR}" ]; then
                        scds_syslog -p daemon.error -t $(syslog_tag) -m \
                        "Validate - Logdirectory %s is non-existent" \
                        "${SAP_LOGDIR}"
                        return 1
                else

			# Validate if SAP_LOG belongs to SAP USER
	
			SAP_LOG_OWNER=`/usr/bin/ls -ld $SAP_LOGDIR | /usr/bin/awk '{print $3}'`

			if [ "${SAP_USER}" != "${SAP_LOG_OWNER}" -o ! -x "${SAP_LOGDIR}" ]; then

				scds_syslog -p daemon.error -t $(syslog_tag) -m
				"Validate - Logdirectory %s is not owned by %s"
				"${SAP_LOGDIR}"  "${SAP_USER}"
				return 1
			else
               		         debug_message "Validate - ${SAP_LOGDIR} exists and is executable also owned by ${SAP_USER} "
                	fi
		fi

        fi

        debug_message "Function: validate - End"

        return 0
}

set_variables()
{

	#
	# Set Variables
	#

        debug_message "Function: set_variables - Begin"
        $SET_DEBUG

	if [ ! -z "${ENV}" ]; then
		return
	fi

	#
	# Set Sap user, User home, Start and stop scripts
	#

	SAPID="`echo ${SAPID} | $LOW2CAP`"
	SAP_STD_PATH=/usr/sap/${SAPID}/SYS/exe/run
	SAP_USER="`echo ${SAPID} | $CAP2LOW`"adm
	SAP_USER_HOME=`/bin/getent passwd ${SAP_USER} | /bin/cut -d: -f6`

	if [ ! -z "${SAP_START}" ];
        then
                SAP_START=${SAP_USER_HOME}/${SAP_START}
	else
		SAP_START=${SAP_STD_PATH}/startsap
	fi

	if [ ! -z "${SAP_STOP}" ];
        then
                SAP_STOP=${SAP_USER_HOME}/${SAP_STOP}
	else
		SAP_STOP=${SAP_STD_PATH}/stopsap
	fi

	if [ ! -z "${SAP_LOGDIR}" ];
        then
                R3S_LOGDIR="R3S_LOGDIR=${SAP_LOGDIR}"
	else
		R3S_LOGDIR=""
	fi



	#
	# Create indexes of SAP J2EE Instancies
	#

	SAP_J2EE_INSTANCIES=`echo ${SAP_J2EE_INSTANCIES} | /bin/tr '+' ' '`

	NR_OF_SAP_J2EE_INSTANCIES=`echo ${SAP_J2EE_INSTANCIES} | /bin/wc -w`

	set -A SAP_J2EE_INSTANCIES_IDX ${SAP_J2EE_INSTANCIES}

	#
	# Set 32- and 64-bits LD_PRELOAD
	#

        if [ -f "${LIBSEC32}/${LIB32}" ]; then

           LD_PRELOAD_32=${LIBSEC32}/${LIB32}
        else
           LD_PRELOAD_32=${DEFLIB}/${LIB32}
        fi
        if [ -f "${LIBSEC64}/${LIB64}" ]; then

           LD_PRELOAD_64=${LIBSEC64}/${LIB64}
        else
           LD_PRELOAD_64=${DEFLIB}/${LIB64}
        fi

	#
	# Set SRM Projects
	#

        srm_function $SAP_USER


	#
	# Set Start/Stop Environment
	#

	ENV="LHOSTNAME=${LHOSTNAME} SAPLOCALHOST=`/usr/bin/hostname` LD_PRELOAD_32=${LD_PRELOAD_32} LD_PRELOAD_64=${LD_PRELOAD_64} DIR_LIBRARY=${SAP_STD_PATH} LD_LIBRARY_PATH=${SAP_STD_PATH} JAVA_HOME=${JAVA_HOME} SAPSYSTEMNAME=${SAPID} HOME=${SAP_USER_HOME} PATH=${JAVA_HOME}/bin:.:${SAP_USER_HOME}:${SAP_STD_PATH}:/usr/bin:/usr/ccs/bin:/usr/ucb ${R3S_LOGDIR}"

	#
	# Get and set Probe_time out
	#

	CONFIGURED_PROBE_TIMEOUT=`extension_resource_get Probe_timeout`

	# Use 75% of the defined Probe_timeout

	USED_PROBE_TIMEOUT=`expr ${CONFIGURED_PROBE_TIMEOUT} \* 75 \/ 100`


        debug_message "Function: set_variables - End"
}


start_sap_j2ee()
{
	
	# Start J2EE Instancies
	#

        debug_message "Function: start_sap_j2ee - Begin"
	$SET_DEBUG

	#
	# Set variables
	#

	set_variables

	#
	# Check if SAP J2EE is started manually
	#

	check_sap_j2ee
	rc_check_sap_j2ee=$?

	if [ "${rc_check_sap_j2ee}" -eq 0 ]
	then
		scds_syslog -p daemon.notice -t $(syslog_tag) -m \
		"start_sap_j2ee - The SAP J2EE instances (%s) is started manually." \
		"${SAP_J2EE_INSTANCIES}"

		create_dummy_process

		return 0
	else
		debug_message "start_sap_j2ee - The SAP J2EE instances (${SAP_J2EE_INSTANCIES}) is not started manually"
	fi



	#
	# Start J2EE Instancies
	#

	nr=0

	while [ ${nr} -lt ${NR_OF_SAP_J2EE_INSTANCIES} ]
	do

		SAPLOGFILE=/tmp/`/bin/basename ${SAP_START}`"_${SAP_J2EE_INSTANCIES_IDX[nr]}_${LHOSTNAME}"

		debug_message "Function: start_sap_j2ee - Start J2EE instance ${SAP_J2EE_INSTANCIES_IDX[nr]} and log output to ${SAPLOGFILE}"

		/bin/su $SAP_USER -c "${TASK_COMMAND} /bin/env -i ${ENV} \
		${SAP_START} J2EE ${SAP_J2EE_INSTANCIES_IDX[nr]}" \
		> ${SAPLOGFILE} 2>&1

		St=$?

		if [ ${St} -ne 0 ];
		then
			scds_syslog -p daemon.error -t $(syslog_tag) -m \
                        "start_sap_j2ee - Failed to start J2EE instance %s returned %s" \
                        "${SAP_J2EE_INSTANCIES_IDX[nr]}" "${St}"

			return 1
        	else
                	debug_message "start_sap_j2ee - J2EE instance ${SAP_J2EE_INSTANCIES_IDX[nr]} started"
        	fi

		nr=$(($nr+1))

	done

        debug_message "Function: start_sap_j2ee - End"

	return 0
}

stop_sap_j2ee()
{
	#
	# Stop J2EE
	#

        debug_message "Function: stop_sap_j2ee - Begin"
	$SET_DEBUG

	stop_status=0

        #
        # Set variables
        #

        set_variables

	#
	# Stop J2EE Instancies
	#

	nr=`expr ${NR_OF_SAP_J2EE_INSTANCIES} - 1`

        while [ ${nr} -ge 0 ]
	do

		SAPLOGFILE=/tmp/`/bin/basename ${SAP_STOP}`"_${SAP_J2EE_INSTANCIES_IDX[nr]}_${LHOSTNAME}"
		
		debug_message "Function: stop_sap_j2ee - Stop J2EE instance ${SAP_J2EE_INSTANCIES_IDX[nr]} and log output to ${SAPLOGFILE}"

		/bin/su $SAP_USER -c "${TASK_COMMAND} /bin/env -i ${ENV} \
		${SAP_STOP} J2EE ${SAP_J2EE_INSTANCIES_IDX[nr]}" \
		> ${SAPLOGFILE} 2>&1

		St=$?

                if [ ${St} -ne 0 ];
                then
                        scds_syslog -p daemon.error -t $(syslog_tag) -m \
                        "stop_sap_j2ee - Failed to stop J2EE instance %s returned %s" \
                        "${SAP_J2EE_INSTANCIES_IDX[nr]}" "${St}"

			stop_status=1
                else
                        debug_message "stop_sap_j2ee - J2EE instance ${SAP_J2EE_INSTANCIES_IDX[nr]} stoped"
                fi


		nr=$(($nr-1))
	done

        debug_message "Function: stop_sap_j2ee - End"

	return ${stop_status}
}

check_sap_j2ee()
{
	#
	# Check SAP J2EE 
	#

	rc_check_sap_j2ee=0

        debug_message "Function: check_sap_j2ee - Begin"
	$SET_DEBUG

        #
        # Set variables
        #

        set_variables


        #
        # Probe J2EE Instancies
        #

        nr=0

        while [ ${nr} -lt ${NR_OF_SAP_J2EE_INSTANCIES} ]
        do

		TMPFILE=/tmp/${RESOURCE}.output

                debug_message "Function: check_sap_j2ee - Check J2EE instance ${SAP_J2EE_INSTANCIES_IDX[nr]}"

		# Run the probe under timeout.
		# The timeout is set to 75% of the Probe_timeout value

		JAVA_PORT=`stripfunc ${SAP_J2EE_INSTANCIES_IDX[nr]}`

		JAVA_PORT=`expr \( ${JAVA_PORT} + 500 \) \* 100`
		

		${HATIMERUN} -e 99 -t ${USED_PROBE_TIMEOUT} ${JAVA_PROBE} ${LHOSTNAME} ${JAVA_PORT} > ${TMPFILE} 2>&1

		St=$?

		if [ ${St} -ne 0 ];
        	then

			#
			# Are we in start-phase
			#

			St=`/bin/ps -ef | /bin/grep "gds_svc_start -R ${RS}" | /bin/grep -v grep`

			if [ -z "${St}" ]; then
				scds_syslog -p daemon.error -t $(syslog_tag) -m \
				"check_sap_j2ee - J2EE instance %s is not running" \
				"${SAP_J2EE_INSTANCIES}" "${St}"
			fi

			rc_check_sap_j2ee=100
		else
			debug_message "check_sap_j2ee - J2EE instance ${SAP_J2EE_INSTANCIES} is running"
		fi

		nr=$(($nr+1))
	done


        debug_message "Function: check_sap_j2ee - End"

	return ${rc_check_sap_j2ee}
}


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"
}
