#! /bin/sh

 

#

# Copyright (c) 1999, 2006 Tanuki Software Inc.

#

# Java Service Wrapper sh script.  Suitable for starting and stopping

#  wrapped Java applications on UNIX platforms.

#

 

#-----------------------------------------------------------------------------

# These settings can be modified to fit the needs of your application

 

# Set this to the root of the Nexus installation

NEXUS_HOME="/app/nexus-2.14.0-01"

 

# If specified, the Wrapper will be run as the specified user.

 

# IMPORTANT - Make sure that the user has the required privileges to write into the Nexus installation directory.

 

# NOTE - This will set the user which is used to run the Wrapper as well as

#  the JVM and is not useful in situations where a privileged resource or

#  port needs to be allocated prior to the user being changed.

RUN_AS_USER=nexus

 

# Application

APP_NAME="nexus"

APP_LONG_NAME="Nexus OSS"

 

# Priority at which to run the wrapper.  See "man nice" for valid priorities.

#  nice is only used if a priority is specified.

PRIORITY=

 

# Location of the pid file.

#PIDDIR="."

 

# If uncommented, causes the Wrapper to be shutdown using an anchor file.

#  When launched with the 'start' command, it will also ignore all INT and

#  TERM signals.

#IGNORE_SIGNALS=true

 

# The following two lines are used by the chkconfig command. Change as is

#  appropriate for your application.  They should remain commented.

# chkconfig: 2345 20 80

# description: Test Wrapper Sample Application

 

# Do not modify anything beyond this point

#-----------------------------------------------------------------------------

 

# Get the fully qualified path to the script

case $0 in

    /*)

        SCRIPT="$0"

        ;;

    *)

        PWD=`pwd`

        SCRIPT="$PWD/$0"

        ;;

esac

 

# Resolve the true real path without any sym links.

CHANGED=true

while [ "X$CHANGED" != "X" ]

do

    # Change spaces to ":" so the tokens can be parsed.

    SAFESCRIPT=`echo $SCRIPT | sed -e 's; ;:;g'`

    # Get the real path to this script, resolving any symbolic links

    TOKENS=`echo $SAFESCRIPT | sed -e 's;/; ;g'`

    REALPATH=

    for C in $TOKENS; do

        # Change any ":" in the token back to a space.

        C=`echo $C | sed -e 's;:; ;g'`

        REALPATH="$REALPATH/$C"

        # If REALPATH is a sym link, resolve it.  Loop for nested links.

        while [ -h "$REALPATH" ] ; do

            LS="`ls -ld "$REALPATH"`"

            LINK="`expr "$LS" : '.*-> \(.*\)$'`"

            if expr "$LINK" : '/.*' > /dev/null; then

                # LINK is absolute.

                REALPATH="$LINK"

            else

                # LINK is relative.

                REALPATH="`dirname "$REALPATH"`""/$LINK"

            fi

        done

    done

 

    if [ "$REALPATH" = "$SCRIPT" ]

    then

        CHANGED=""

    else

        SCRIPT="$REALPATH"

    fi

done

 

# Change the current directory to the location of the script

cd "`dirname "$REALPATH"`"

REALDIR=`pwd`

 

# Resolve the location of the 'ps' command

PSEXE="/usr/bin/ps"

if [ ! -x "$PSEXE" ]

then

    PSEXE="/bin/ps"

    if [ ! -x "$PSEXE" ]

    then

        echo "Unable to locate 'ps'."

        echo "Please report this message along with the location of the command on your system."

        exit 1

    fi

fi

 

# Resolve the os

DIST_OS=`uname -s | tr [:upper:] [:lower:] | tr -d [:blank:]`

case "$DIST_OS" in

    'sunos')

        DIST_OS="solaris"

        PSEXE="/usr/ucb/ps"

        ;;

    'hp-ux' | 'hp-ux64')

        DIST_OS="hpux"

        ;;

    'darwin')

        DIST_OS="macosx"

        ;;

    'unix_sv')

        DIST_OS="unixware"

        ;;

esac

 

# Resolve the architecture

DIST_ARCH=`uname -p | tr [:upper:] [:lower:] | tr -d [:blank:]`

DIST_BITS=32

if [ "$DIST_ARCH" = "unknown" ]

then

    DIST_ARCH=`uname -m | tr [:upper:] [:lower:] | tr -d [:blank:]`

fi

case "$DIST_ARCH" in

    'athlon' | 'ia32' | 'i386' | 'i486' | 'i586' | 'i686')

        DIST_ARCH="x86"

        ;;

    'amd64' | 'x86_64' | 'ia64')

        DIST_ARCH="x86"

        DIST_BITS=64

        ;;

    'ip27')

        DIST_ARCH="mips"

        ;;

    'power' | 'powerpc' | 'power_pc')

        DIST_ARCH="ppc"

        ;;

    'ppc64')

        DIST_ARCH="ppc"

        DIST_BITS=64

        ;;

    'pa_risc' | 'pa-risc')

        DIST_ARCH="parisc"

        ;;

    'sun4u' | 'sparcv9')

        DIST_ARCH="sparc"

        ;;

    '9000/800')

        DIST_ARCH="parisc"

        ;;

esac

 

# Extra architecture detection

case "$DIST_OS" in

    'macosx')

        if [ `sysctl hw.cpu64bit_capable | awk '{ print $2 }'` = '1' ]; then

            DIST_BITS=64

        fi

        DIST_ARCH='universal'

        ;;

    'aix')

        DIST_BITS=`getconf KERNEL_BITMODE`

        ;;

esac

 

outputFile() {

    if [ -f "$1" ]

    then

        echo "  $1 (Found but not executable.)";

    else

        echo "  $1"

    fi

}

 

# Test if NEXUS_HOME is relative (does not start with /). If relative it should be relative to this script location

FIRST_CHAR=`echo $NEXUS_HOME | cut -c1,1`

if [ "$FIRST_CHAR" != "/" ]

then

    NEXUS_HOME=$REALDIR/$NEXUS_HOME

fi

 

# Default PIDDIR to os/arch/bits directory

if [ "X$PIDDIR" = "X" ]

then

    PIDDIR="bin/jsw/$DIST_OS-$DIST_ARCH-$DIST_BITS"

fi

 

# If the PIDDIR is relative, set its value relative to the full NEXUS_HOME to avoid problems if

#  the working directory is later changed.

FIRST_CHAR=`echo $PIDDIR | cut -c1,1`

if [ "$FIRST_CHAR" != "/" ]

then

    PIDDIR=$NEXUS_HOME/$PIDDIR

fi

 

# Process ID

ANCHORFILE="$PIDDIR/$APP_NAME.anchor"

PIDFILE="$PIDDIR/$APP_NAME.pid"

LOCKDIR="/var/lock/subsys"

LOCKFILE="$LOCKDIR/$APP_NAME"

pid=""

 

WRAPPER_CMD="$NEXUS_HOME/bin/jsw/$DIST_OS-$DIST_ARCH-$DIST_BITS/wrapper"

if [ ! -x "$WRAPPER_CMD" ]; then

    echo "Missing platform binary: $WRAPPER_CMD"

    exit 1

fi

 

WRAPPER_CONF="$NEXUS_HOME/bin/jsw/conf/wrapper.conf"

 

# Build the nice clause

if [ "X$PRIORITY" = "X" ]

then

    CMDNICE=""

else

    CMDNICE="nice -$PRIORITY"

fi

 

# Build the anchor file clause.

if [ "X$IGNORE_SIGNALS" = "X" ]

then

   ANCHORPROP=

   IGNOREPROP=

else

   ANCHORPROP=wrapper.anchorfile=\"$ANCHORFILE\"

   IGNOREPROP=wrapper.ignore_signals=TRUE

fi

 

# Build the lock file clause.  Only create a lock file if the lock directory exists on this platform.

LOCKPROP=

if [ -d $LOCKDIR ]

then

    if [ -w $LOCKDIR ]

    then

        LOCKPROP=wrapper.lockfile=\"$LOCKFILE\"

    fi

fi

 

checkUser() {

    # $1 touchLock flag

    # $2 command

 

    # Resolve the location of the 'id' command

    IDEXE="/usr/xpg4/bin/id"

    if [ ! -x "$IDEXE" ]

    then

        IDEXE="/usr/bin/id"

        if [ ! -x "$IDEXE" ]

        then

            echo "Unable to locate 'id'."

            echo "Please report this message along with the location of the command on your system."

            exit 1

        fi

    fi

 

    # Check the configured user.  If necessary rerun this script as the desired user.

    if [ "X$RUN_AS_USER" != "X" ]

    then

        if [ "`$IDEXE -u -n`" != "$RUN_AS_USER" ]

        then

            # If LOCKPROP and $RUN_AS_USER are defined then the new user will most likely not be

            # able to create the lock file.  The Wrapper will be able to update this file once it

            # is created but will not be able to delete it on shutdown.  If $2 is defined then

            # the lock file should be created for the current command

            if [ "X$LOCKPROP" != "X" ]

            then

                if [ "X$1" != "X" ]

                then

                    # Resolve the primary group

                    RUN_AS_GROUP=`groups $RUN_AS_USER | awk '{print $3}' | tail -1`

                    if [ "X$RUN_AS_GROUP" = "X" ]

                    then

                        RUN_AS_GROUP=$RUN_AS_USER

                    fi

                    touch $LOCKFILE

                    chown $RUN_AS_USER:$RUN_AS_GROUP $LOCKFILE

                fi

            fi

 

            # Still want to change users, recurse.  This means that the user will only be

            #  prompted for a password once. Variables shifted by 1

            #su - $RUN_AS_USER -c "\"$REALPATH\" $2"

            sudo -E -u $RUN_AS_USER $REALPATH $2

 

            # Now that we are the original user again, we may need to clean up the lock file.

            if [ "X$LOCKPROP" != "X" ]

            then

                getpid

                if [ "X$pid" = "X" ]

                then

                    # Wrapper is not running so make sure the lock file is deleted.

                    if [ -f "$LOCKFILE" ]

                    then

                        rm "$LOCKFILE"

                    fi

                fi

            fi

 

            exit 0

        fi

    fi

 

    # Check that script is not run as root

    LUID=`$IDEXE -u`

    if [ $LUID -eq 0 ]

    then

        echo "****************************************"

        echo "WARNING - NOT RECOMMENDED TO RUN AS ROOT"

        echo "****************************************"

        if [ ! "`$IDEXE -u -n`" = "$RUN_AS_USER" ]

        then

            echo "If you insist running as root, then set the environment variable RUN_AS_USER=root before running this script."

            exit 1

        fi

    fi

}

 

getpid() {

    if [ -f "$PIDFILE" ]

    then

        if [ -r "$PIDFILE" ]

        then

            pid=`cat "$PIDFILE"`

            if [ "X$pid" != "X" ]

            then

                # It is possible that 'a' process with the pid exists but that it is not the

                #  correct process.  This can happen in a number of cases, but the most

                #  common is during system startup after an unclean shutdown.

                # The ps statement below looks for the specific wrapper command running as

                #  the pid.  If it is not found then the pid file is considered to be stale.

                case "$DIST_OS" in

                    'macosx')

                        pidtest=`$PSEXE -ww -p $pid -o command | grep "wrapper.pidfile" | tail -1`

                        ;;

                    'solaris')

                        pidtest=`$PSEXE ww $pid | grep "wrapper.pidfile" | tail -1`

                        ;;

                    *)

                        pidtest=`$PSEXE -p $pid -o args | grep "wrapper.pidfile" | tail -1`

                        ;;

                esac

                if [ "X$pidtest" = "X" ]

                then

                    # This is a stale pid file.

                    rm -f "$PIDFILE"

                    echo "Removed stale pid file: $PIDFILE"

                    pid=""

                fi

            fi

        else

            echo "Cannot read $PIDFILE."

            exit 1

        fi

    fi

}

 

testpid() {

    if [ "$DIST_OS" = "solaris" ]

    then

        pid=`$PSEXE ww $pid | grep $pid | grep -v grep | awk '{print $1}' | tail -1`

    else

        pid=`$PSEXE -p $pid | grep $pid | grep -v grep | awk '{print $1}' | tail -1`

    fi

    if [ "X$pid" = "X" ]

    then

        # Process is gone so remove the pid file.

        rm -f "$PIDFILE"

        pid=""

    fi

}

 

console() {

    echo "Running $APP_LONG_NAME..."

    getpid

    if [ "X$pid" = "X" ]

    then

        # The string passed to eval must handles spaces in paths correctly.

        COMMAND_LINE="$CMDNICE \"$WRAPPER_CMD\" \"$WRAPPER_CONF\" wrapper.syslog.ident=$APP_NAME wrapper.pidfile=\"$PIDFILE\" $ANCHORPROP $LOCKPROP"

        eval $COMMAND_LINE

    else

        echo "$APP_LONG_NAME is already running."

        exit 1

    fi

}

 

start() {

    echo "Starting $APP_LONG_NAME..."

    getpid

    if [ "X$pid" = "X" ]

    then

        # The string passed to eval must handles spaces in paths correctly.

        COMMAND_LINE="$CMDNICE \"$WRAPPER_CMD\" \"$WRAPPER_CONF\" wrapper.syslog.ident=$APP_NAME wrapper.pidfile=\"$PIDFILE\" wrapper.daemonize=TRUE $ANCHORPROP $IGNOREPROP $LOCKPROP"

        eval $COMMAND_LINE

    else

        echo "$APP_LONG_NAME is already running."

        exit 1

    fi

    getpid

    if [ "X$pid" != "X" ]

    then

        echo "Started $APP_LONG_NAME."

    else

        echo "Failed to start $APP_LONG_NAME."

    fi

}

 

stopit() {

    echo "Stopping $APP_LONG_NAME..."

    getpid

    if [ "X$pid" = "X" ]

    then

        echo "$APP_LONG_NAME was not running."

    else

        if [ "X$IGNORE_SIGNALS" = "X" ]

        then

            # Running so try to stop it.

            kill $pid

            if [ $? -ne 0 ]

            then

                # An explanation for the failure should have been given

                echo "Unable to stop $APP_LONG_NAME."

                exit 1

            fi

        else

            rm -f "$ANCHORFILE"

            if [ -f "$ANCHORFILE" ]

            then

                # An explanation for the failure should have been given

                echo "Unable to stop $APP_LONG_NAME."

                exit 1

            fi

        fi

 

        # We can not predict how long it will take for the wrapper to

        #  actually stop as it depends on settings in wrapper.conf.

        #  Loop until it does.

        savepid=$pid

        CNT=0

        TOTCNT=0

        while [ "X$pid" != "X" ]

        do

            # Show a waiting message every 5 seconds.

            if [ "$CNT" -lt "5" ]

            then

                CNT=`expr $CNT + 1`

            else

                echo "Waiting for $APP_LONG_NAME to exit..."

                CNT=0

            fi

            TOTCNT=`expr $TOTCNT + 1`

 

            sleep 1

 

            testpid

        done

 

        pid=$savepid

        testpid

        if [ "X$pid" != "X" ]

        then

            echo "Failed to stop $APP_LONG_NAME."

            exit 1

        else

            echo "Stopped $APP_LONG_NAME."

        fi

    fi

}

 

status() {

    getpid

    if [ "X$pid" = "X" ]

    then

        echo "$APP_LONG_NAME is not running."

        exit 1

    else

        echo "$APP_LONG_NAME is running ($pid)."

        exit 0

    fi

}

 

dump() {

    echo "Dumping $APP_LONG_NAME..."

    getpid

    if [ "X$pid" = "X" ]

    then

        echo "$APP_LONG_NAME was not running."

 

    else

        kill -3 $pid

 

        if [ $? -ne 0 ]

        then

            echo "Failed to dump $APP_LONG_NAME."

            exit 1

        else

            echo "Dumped $APP_LONG_NAME."

        fi

    fi

}

 

case "$1" in

 

    'console')

        checkUser touchlock $1

        console

        ;;

 

    'start')

        checkUser touchlock $1

        start

        ;;

 

    'stop')

        checkUser "" $1

        stopit

        ;;

 

    'restart')

        checkUser touchlock $1

        stopit

        start

        ;;

 

    'status')

        checkUser "" $1

        status

        ;;

 

    'dump')

        checkUser "" $1

        dump

        ;;

 

    *)

        echo "Usage: $0 { console | start | stop | restart | status | dump }"

        exit 1

        ;;

esac

 

exit 0
