jenkins

#!/bin/bash
# /etc/init.d/jenkins
# debian-compatible jenkins startup script.
# Amelia A Lewis <alewis@ibco.com>
#
### BEGIN INIT INFO
# Provides:          jenkins
# Required-Start:    $remote_fs $syslog $network
# Required-Stop:     $remote_fs $syslog $network
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start Jenkins at boot time
# Description:       Controls Jenkins Automation Server
### END INIT INFO

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

DESC="Jenkins Automation Server"
NAME=jenkins
SCRIPTNAME=/etc/init.d/$NAME

[ -r /etc/default/$NAME ] && . /etc/default/$NAME

#DAEMON=$JENKINS_SH
DAEMON=/usr/bin/daemon
DAEMON_ARGS="--name=$NAME --inherit --env=JENKINS_HOME=$JENKINS_HOME --output=$JENKINS_LOG --pidfile=$PIDFILE"
JAVA=`type -p java`

if [ -n "$UMASK" ]; then
    DAEMON_ARGS="$DAEMON_ARGS --umask=$UMASK"
fi
if [ "$JENKINS_ENABLE_ACCESS_LOG" = "yes" ]; then
    JENKINS_ARGS="$JENKINS_ARGS --accessLoggerClassName=winstone.accesslog.SimpleAccessLogger --simpleAccessLogger.format=combined --simpleAccessLogger.file=/var/log/$NAME/access_log"
fi

SU=/bin/su

# Exit if the package is not installed
if [ ! -x "$DAEMON" ]; then
    echo "daemon package not installed" >&2
    exit 1
fi

# Exit if not supposed to run standalone
if [ "$RUN_STANDALONE" = "false" ]; then
    echo "Not configured to run standalone" >&2
    exit 1
fi

# Make sure there exists a java executable, it may not be always the case
if [ -z "$JAVA" ]; then
    echo "ERROR: No Java executable found in current PATH: $PATH" >&2
    echo "If you actually have java installed on the system make sure the executable is in the aforementioned path and that 'type -p java' returns the java executable path" >&2
    exit 1
fi

# Which Java versions can be used to run Jenkins
JAVA_ALLOWED_VERSIONS=( "1.8" "11" )
# Work out the JAVA version we are working with:
JAVA_VERSION=$($JAVA -version 2>&1 | sed -n ';s/.* version "\([0-9]\{2,\}\|[0-9]\.[0-9]\)\..*".*/\1/p;')

if [[ ${JAVA_ALLOWED_VERSIONS[*]} =~ "$JAVA_VERSION" ]]; then
    echo "Correct java version found" >&2
else
    echo "Found an incorrect Java version" >&2
    echo "Java version found:" >&2
    echo $($JAVA -version) >&2
    echo "Aborting" >&2
    exit 1
fi

# load environments
if [ -r /etc/default/locale ]; then
  . /etc/default/locale
  export LANG LANGUAGE
elif [ -r /etc/environment ]; then
  . /etc/environment
  export LANG LANGUAGE
fi

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions

# Make sure we run as root, since setting the max open files through
# ulimit requires root access
if [ `id -u` -ne 0 ]; then
    echo "The $NAME init script can only be run as root"
    exit 1
fi


check_tcp_port() {
    local service=$1
    local assigned=$2
    local default=$3
    local assigned_address=$4
    local default_address=$5

    if [ -n "$assigned" ]; then
        port=$assigned
    else
        port=$default
    fi

    if [ -n "$assigned_address" ]; then
        address=$assigned_address
    else
        address=$default_address
    fi

    count=`netstat --listen --numeric-ports | grep $address\:$port[[:space:]] | grep -c . `

    if [ $count -ne 0 ]; then
        echo "The selected $service port ($port) on address $address seems to be in use by another program "
        echo "Please select another address/port combination to use for $NAME"
        return 1
    fi
}

#
# Function that starts the daemon/service
#
do_start()
{
    # java will store heap dumps here in case of OutOfMemoryError.
    # delete old heap dumps when starting
    rm -r "$JENKINS_HOME/heapDumps/" > /dev/null 2>&1 || true
    mkdir -p "$JENKINS_HOME/heapDumps/"
    chown ${JENKINS_USER}.${JENKINS_GROUP} "$JENKINS_HOME/heapDumps"
    # the default location is /var/run/jenkins/jenkins.pid but the parent directory needs to be created
    mkdir `dirname $PIDFILE` > /dev/null 2>&1 || true
    chown $JENKINS_USER `dirname $PIDFILE`
    # Return
    #   0 if daemon has been started
    #   1 if daemon was already running
    #   2 if daemon could not be started
    $DAEMON $DAEMON_ARGS --running && return 1

    # Verify if there is a jenkins process already running without a daemon
    get_running || return 2

    # Verify that the jenkins port is not already in use, winstone does not exit
    # even for BindException
    check_tcp_port "http" "$HTTP_PORT" "8080" "$HTTP_HOST" "0.0.0.0" || return 2

    # If the var MAXOPENFILES is enabled in /etc/default/jenkins then set the max open files to the
    # proper value
    if [ -n "$MAXOPENFILES" ]; then
        [ "$VERBOSE" != no ] && echo Setting up max open files limit to $MAXOPENFILES
        ulimit -n $MAXOPENFILES
    fi

    # notify of explicit umask
    if [ -n "$UMASK" ]; then
        [ "$VERBOSE" != no ] && echo Setting umask to $UMASK
    fi

    # --user in daemon doesn't prepare environment variables like HOME, USER, LOGNAME or USERNAME,
    # so we let su do so for us now
    $SU -l $JENKINS_USER --shell=/bin/bash -c "$DAEMON $DAEMON_ARGS -- $JAVA $JAVA_ARGS -jar $JENKINS_WAR $JENKINS_ARGS" || return 2
}


#
# Verify that all jenkins processes have been shutdown
#
get_running()
{
    return `ps -U $JENKINS_USER --no-headers -f | egrep -e '(java)' | grep -v defunct | grep -c . `
}

#
# killall jenkins processes that have not been shutdown
#
force_stop()
{
    get_running
    if [ $? -ne 0 ]; then
	killall -u $JENKINS_USER java daemon || return 3
         # wait for the process to really terminate
         for n in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
             sleep 1
             get_running && return 0
         done
         return 2
    fi
}

# Get the status of the daemon process
get_daemon_status()
{
    $DAEMON $DAEMON_ARGS --running || return 1
}


#
# Function that stops the daemon/service
#
do_stop()
{
    # Return
    #   0 if daemon has been stopped
    #   1 if daemon was already stopped
    #   2 if daemon could not be stopped
    #   other if a failure occurred
    get_daemon_status
    case "$?" in
	0)
	    $DAEMON $DAEMON_ARGS --stop || return 2
        # wait for the process to really terminate
        for n in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
            sleep 1
            $DAEMON $DAEMON_ARGS --running || break
        done
        if get_daemon_status; then
	        force_stop || return "$?"
        fi
	    ;;
	*)
	    force_stop || return "$?"
	    ;;
    esac

    # Many daemons don't delete their pidfiles when they exit.
    rm -f $PIDFILE
    return 0
}

# Verify the process did in fact start successfully and didn't just bomb out
do_check_started_ok() {
    sleep 1
    if [ "$1" -ne "0" ]; then return $1; fi
    get_running
    if [ "$?" -eq "0" ]; then
        return 2
    else
        return 0
    fi
}

case "$1" in
  start)
    log_daemon_msg "Starting $DESC" "$NAME"
    do_start
    START_STATUS="$?"
    do_check_started_ok "$START_STATUS"
    case "$?" in
        0|1) log_end_msg 0 ;;
        2) log_end_msg 1 ; exit 7 ;;
    esac
    ;;
  stop)
    log_daemon_msg "Stopping $DESC" "$NAME"
    do_stop
    case "$?" in
        0|1) log_end_msg 0 ;;
        2|3) log_end_msg 1 ; exit 100 ;;
    esac
    ;;
  restart|force-reload)
    #
    # If the "reload" option is implemented then remove the
    # 'force-reload' alias
    #
    log_daemon_msg "Restarting $DESC" "$NAME"
    do_stop
    case "$?" in
      0|1)
        do_start
        START_STATUS="$?"
        sleep 1
        do_check_started_ok "$START_STATUS"
        case "$?" in
          0) log_end_msg 0 ;;
          1) log_end_msg 1 ; exit 100 ;; # Old process is still running
          *) log_end_msg 1 ; exit 100 ;; # Failed to start
        esac
        ;;
      *)
  	# Failed to stop
	log_end_msg 1
	;;
    esac
    ;;
  status)
	get_daemon_status
	case "$?" in
	 0)
		echo "$DESC is running with the pid `cat $PIDFILE`"
		rc=0
		;;
	*)
		get_running
		procs=$?
		if [ $procs -eq 0 ]; then
			echo -n "$DESC is not running"
			if [ -f $PIDFILE ]; then
				echo ", but the pidfile ($PIDFILE) still exists"
				rc=1
			else
				echo
				rc=3
			fi

		else
			echo "$procs instances of jenkins are running at the moment"
			echo "but the pidfile $PIDFILE is missing"
			rc=0
		fi

		exit $rc
		;;
	esac
	;;
  *)
    echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
    exit 3
    ;;
esac

exit 0