#!/bin/sh
#
#    Licensed to the Apache Software Foundation (ASF) under one or more
#    contributor license agreements.  See the NOTICE file distributed with
#    this work for additional information regarding copyright ownership.
#    The ASF licenses this file to You under the Apache License, Version 2.0
#    (the "License"); you may not use this file except in compliance with
#    the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.

# Script structure inspired from Apache Karaf and other Apache projects with similar startup approaches

SCRIPT_DIR=$(dirname "$0")
SCRIPT_NAME=$(basename "$0")
PROGNAME=$(basename "$0")
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
export MINIFI_HOME="$(dirname ${SCRIPTPATH})"
bin_dir=${MINIFI_HOME}/bin
minifi_executable=${bin_dir}/minifi
pid_file=${bin_dir}/.minifi.pid

warn() {
    echo "${PROGNAME}: $*"
}

die() {
    warn "$*"
    exit 1
}

detectOS() {
    # OS specific support (must be 'true' or 'false').
    cygwin=false;
    aix=false;
    os400=false;
    darwin=false;
    case "$(uname)" in
        CYGWIN*)
            cygwin=true
            ;;
        AIX*)
            aix=true
            ;;
        OS400*)
            os400=true
            ;;
        Darwin)
            darwin=true
            ;;
    esac
    # For AIX, set an environment variable
    if ${aix}; then
         export LDR_CNTRL=MAXDATA=0xB0000000@DSA
         echo ${LDR_CNTRL}
    fi
}

init() {
    # Determine if there is special OS handling we must perform
    detectOS
}

# determines the pid
get_pid() {
  # Default to a -1 for pid
  pid=-1
  # Check to see if we have a pid file
  if [ -f ${pid_file} ]; then
    pid=$(cat ${pid_file})
  fi
  echo ${pid}
}

# Performs a check to see if the provided pid is one that currently exists
active_pid() {
  pid=${1}
  if [ ${pid} -eq -1 ]; then
    echo 1
  else
    kill -s 0 ${pid} > /dev/null 2>&1
    echo $?
  fi
}

endnow() {
   echo "Killing MiNiFi..."
   kill -9 ${saved_pid} > /dev/null 2>&1
   
}

install() {
    detectOS

    if [ "${darwin}" = "true"  ] || [ "${cygwin}" = "true" ]; then
        echo 'Installing Apache MiNiFi as a service is not supported on OS X or Cygwin.'
        exit 1
    fi

    SVC_NAME=minifi
    if [ "x$2" != "x" ] ; then
        SVC_NAME=$2
    fi

    initd_dir='/etc/init.d'
    SVC_FILE="${initd_dir}/${SVC_NAME}"

    if [ ! -w  "${initd_dir}" ]; then
        echo "Current user does not have write permissions to ${initd_dir}. Cannot install MiNiFi as a service."
        exit 1
    fi

# Create the init script, overwriting anything currently present
cat <<SERVICEDESCRIPTOR > ${SVC_FILE}
#!/bin/sh
#
#    Licensed to the Apache Software Foundation (ASF) under one or more
#    contributor license agreements.  See the NOTICE file distributed with
#    this work for additional information regarding copyright ownership.
#    The ASF licenses this file to You under the Apache License, Version 2.0
#    (the "License"); you may not use this file except in compliance with
#    the License.  You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
# chkconfig: 2345 20 80
# description: Apache NiFi MiNiFi is a subproject of Apache nifi to collect data where it originates.
#
# Make use of the configured MINIFI_HOME directory and pass service requests to the minifi executable
export MINIFI_HOME=${MINIFI_HOME}
bin_dir=\${MINIFI_HOME}/bin
minifi_executable=\${bin_dir}/minifi
pid_file="\${bin_dir}/.minifi.pid"

# determines the pid
get_pid() {
  # Default to a -1 for pid
  pid=-1
  # Check to see if we have a pid file
  if [ -f \${pid_file} ]; then
    pid=\$(cat "\${pid_file}")
  fi
  echo \${pid}
}

# Performs a check to see if the provided pid is one that currently exists
active_pid() {
  pid=\${1}
  if [ \${pid} -eq -1 ]; then
    echo 1
  else
    kill -s 0 \${pid} > /dev/null 2>&1
    echo \$?
  fi
}

saved_pid=\$(get_pid)

case "\$1" in
    start)
      if [ "\${saved_pid}" -gt 0 ]; then
        if [ \$(active_pid \${saved_pid}) -ne 0 ]; then
            echo "PID \${saved_pid} is stale, removing pid file at \${pid_file}";
            if ! rm -f \${pid_file}; then
              echo "Could not remove \${pid_file}. File will need to be manually removed."
              exit 1;
            fi
        else
            echo "MINIFI is currently running (PID: \${saved_pid}) with pid file \${pid_file}."
            exit 0;
        fi
      fi
      \${minifi_executable} &
      pid=\$!
      echo \${pid} > \${pid_file}
      echo Starting MiNiFi with PID \${pid} and pid file \${pid_file}
      ;;
    stop)
      if [ \$(active_pid \${saved_pid}) -ne 0 ]; then
        echo "MiNiFi is not currently running."
      else
        echo "Stopping MiNiFi (PID: \${saved_pid})."
        # Send a SIGINT to MiNiFi so that the handler begins shutdown.
        kill -2 \${saved_pid} > /dev/null 2>&1
        if [ \$? -ne 0 ]; then
          echo "Could not successfully send termination signal to MiNiFi (PID: \${saved_pid})"
          exit 1;
        else
          # Clean up our pid file
          rm -f \${pid_file}
        fi
      fi
      ;;
    run)
      if [ "\${saved_pid}" -gt 0 ]; then
        if ! active_pid \${saved_pid}; then
            echo "PID \${saved_pid} is stale, removing pid file at \${pid_file}";
            if ! rm -f \${pid_file}; then
              echo "Could not remove \${pid_file}. File will need to be manually removed."
              exit 1;
            fi
        else
            echo "MINIFI is currently running (PID: \${saved_pid}) with pid file \${pid_file}."
            exit 0;
        fi
      fi
      echo running
      \${minifi_executable}
      ;;
    status)
        # interpret status as per LSB specifications
        # see:  http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html

        if [ "\${saved_pid}" -gt 0 ]; then
          if [ \$(active_pid \${saved_pid}) -ne 0 ]; then
            # program is dead and pid file exists
            echo "Program is not currently running but stale pid file (\${pid_file}) exists.";
            exit 1
          else
            # pid is correct, program is running
            echo "MINIFI is currently running (PID: \${saved_pid}) with pid file \${pid_file}."
            exit 0;
          fi
        else
          # program is not running
          echo "MiNiFi is not currently running."
          exit 3;
        fi
        ;;
     update) 
        if [  -f \${bin_dir}/minifi.update ]; then
        	 \${bin_dir}/minifi.sh stop
        	 cp \${bin_dir}/minifi \${bin_dir}/minifi.bak
             cp \${bin_dir}/minifi.update \${bin_dir}/minifi
             # ensure that the command is now running
             \${bin_dir}/minifi.sh start
             saved_pid=\$(get_pid)
             if [ "\${saved_pid}" -gt 0 ]; then
        	    if [ \$(active_pid \${saved_pid}) -ne 0 ]; then
        	        cp \${bin_dir}/minifi.bak \${bin_dir}/minifi
        	 		\${bin_dir}/minifi.sh start       
        	    fi
        	 fi
		fi
        ;;
    restart)
      echo "Restarting the MiNiFi service. Hit CTRL+C at any time to forcibly terminate MiNiFi"
      "\${bin_dir}/minifi.sh" stop
      ticks=1
      printf "Waiting for process to terminate."
      trap endnow INT
      if [ "\${saved_pid}" -gt 0 ]; then
        while [ "\$(active_pid \${saved_pid})" -eq 0 ]; do
                sleep 1
                ticks="\$((ticks+1))"
                numticks="\$((ticks % 5))"
                if [ "\${numticks}"  -eq 0 ]; then
                        printf "."
                fi
        done
      fi
      "\${bin_dir}/minifi.sh" start
	;;
    *)
        echo "Usage: service minifi {start|stop|restart|status}"
        ;;
esac

SERVICEDESCRIPTOR

    if [ ! -f "${SVC_FILE}" ]; then
        echo "Could not create service file ${SVC_FILE}"
        exit 1
    fi

    # Provide the user execute access on the file
    chmod u+x ${SVC_FILE}

    rm -f "/etc/rc2.d/S65${SVC_NAME}"
    ln -s "/etc/init.d/${SVC_NAME}" "/etc/rc2.d/S65${SVC_NAME}" || { echo "Could not create link /etc/rc2.d/S65${SVC_NAME}"; exit 1; }
    rm -f "/etc/rc2.d/K65${SVC_NAME}"
    ln -s "/etc/init.d/${SVC_NAME}" "/etc/rc2.d/K65${SVC_NAME}" || { echo "Could not create link /etc/rc2.d/K65${SVC_NAME}"; exit 1; }
    echo "Service ${SVC_NAME} installed"
}

saved_pid=$(get_pid)

case "$1" in
    start)
      if [ "${saved_pid}" -gt 0 ]; then
        if [ $(active_pid ${saved_pid}) -ne 0 ]; then
            echo "PID ${saved_pid} is stale, removing pid file at ${pid_file}";
            if ! rm -f ${pid_file}; then
              echo "Could not remove ${pid_file}. File will need to be manually removed."
              exit 1;
            fi
        else
            echo "MINIFI is currently running (PID: ${saved_pid}) with pid file ${pid_file}."
            exit 0;
        fi
      fi
      ${minifi_executable} &
      pid=$!
      echo ${pid} > ${pid_file}
      echo Starting MiNiFi with PID ${pid} and pid file ${pid_file}
      ;;
    stop)
      if [ $(active_pid ${saved_pid}) -ne 0 ]; then
        echo "MiNiFi is not currently running."
      else
        echo "Stopping MiNiFi (PID: ${saved_pid})."
        # Send a SIGINT to MiNiFi so that the handler begins shutdown.
        kill -2 ${saved_pid} > /dev/null 2>&1
        if [ $? -ne 0 ]; then
          echo "Could not successfully send termination signal to MiNiFi (PID: ${saved_pid})"
          exit 1;
        else
          # Clean up our pid file
          rm -f ${pid_file}
        fi
      fi
      ;;
    run)
      if [ "${saved_pid}" -gt 0 ]; then
        if [ $(active_pid ${saved_pid}) -ne 0 ]; then
            echo "PID ${saved_pid} is stale, removing pid file at ${pid_file}";
            if ! rm -f ${pid_file}; then
              echo "Could not remove ${pid_file}. File will need to be manually removed."
              exit 1;
            fi
        else
            echo "MINIFI is currently running (PID: ${saved_pid}) with pid file ${pid_file}."
            exit 0;
        fi
      fi
      ${minifi_executable}
      ;;
    status)
      if [ "${saved_pid}" -gt 0 ]; then
        if [ $(active_pid ${saved_pid}) -ne 0 ]; then
          # program is dead and pid file exists
          echo "Program is not currently running but stale pid file (${pid_file}) exists.";
          exit 1
        else
          # pid is correct, program is running
          echo "MINIFI is currently running (PID: ${saved_pid}) with pid file ${pid_file}."
          exit 0;
        fi
      else
        # program is not running
        echo "MiNiFi is not currently running."
        exit 0;
      fi
      ;;
    update) 
        if [  -f ${bin_dir}/minifi.update ]; then
        	 ${bin_dir}/minifi.sh stop
        	 cp ${bin_dir}/minifi ${bin_dir}/minifi.bak
             cp ${bin_dir}/minifi.update ${bin_dir}/minifi
             # ensure that the command is now running
             ${bin_dir}/minifi.sh start
             saved_pid=$(get_pid)
             if [ "${saved_pid}" -gt 0 ]; then
        	    if [ $(active_pid ${saved_pid}) -ne 0 ]; then
        	        cp ${bin_dir}/minifi.bak ${bin_dir}/minifi
        	 		${bin_dir}/minifi.sh start       
        	    fi
        	 fi
		fi
        ;;
    restart)
      echo "Restarting MiNiFi. Hit CTRL+C at any time to forcibly terminate MiNiFi"
      ${bin_dir}/minifi.sh stop
      ticks=1
      printf "Waiting for process to terminate."
      trap endnow INT
      if [ "${saved_pid}" -gt 0 ]; then
      	while [ $(active_pid ${saved_pid}) -eq 0 ]; do
  		sleep 1
		ticks=$((ticks+1))
		numticks=$(($ticks % 5))
		if [ "${numticks}"  -eq 0 ]; then
			printf "."
		fi
        done
      fi
      ${bin_dir}/minifi.sh start
      ;;
    install)
      install "$@"
      ;;
    *)
      echo "Usage: minifi.sh {start|stop|run|restart|status|install}"
      ;;
esac