#!/usr/bin/env bash

# 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.
#
# =========
#
# Startup script for Fuseki under *nix systems (works with cygwin too)
#
# Configuration
# -------------
# Values are loaded from /etc/default/fuseki, if it exists.
# The description below cover the default settings if /etc/default/fuseki
# does not exist.
#
# Set DEBUG=1 (see below or set the environment variable) to print the
# settings to be used.
#
# JAVA
#   Command to invoke Java. If not set, java (from the PATH) will be used.
#   JAVA_HOME can also be used to set JAVA.
#
# JAVA_OPTIONS
#   Extra options to pass to the JVM.
#
# FUSEKI_HOME
#   Where Fuseki is installed.  If not set, the script will try
#   to guess it based on the script invokation path.
# 
# FUSEKI_BASE
#   The root of the runtime area - logs files, system files, local configuration.
#   Defaults to $FUSEKI_HOME/run.
#
# FUSEKI_RUN
#   Where the fuseki.pid file should be stored.  It defaults
#   first available of /var/run, /usr/var/run, $FUSEKI_HOME and /tmp if not set.
#
# FUSEKI_PID
#   The FUSEKI PID file, defaults to $FUSEKI_RUN/fuseki.pid
#
# FUSEKI_ARGS
#   The arguments to pass to the Fuseki server on the command line. Defaults to:
#                                        # if FUSEKI_CONF is not set
#    --config=$FUSEKI_CONF               # if FUSEKI_CONF is set
#
# FUSEKI_START
#   Path to the jar file. Defaults to $FUSEKI_HOME/fuseki-server.jar 
#
# FUSEKI_CLASSES
#   Path to extra jars to add to the class path.  Defaults to none
#   Should be of the form path/class.jar:path/class2.jar
#
# FUSEKI_CONF
#   The Fuseki configuration file, usually in RDF Turtle notation.
#
# FUSEKI_USER
#   If set, the server will be run as this user
#
# FUSEKI_LOGS
#   Directory where logs will be generated. 
#   Fixed as $FUSEKI_BASE/logs.
#
# FUSEKI_LOGS_STDERROUT
#   Log file with stderr and stdout log output from Fuseki. 
#   Defaults to $FUSEKI_LOGS/stderrout.log


### BEGIN INIT INFO
# Provides:          fuseki
# Required-Start:    $remote_fs $network
# Required-Stop:     $remote_fs $network
# Default-Start:     3 4 5
# Default-Stop:      0 1 2 6
# Short-Description: Start Jena Fuseki at boot time
# Description:       Apache Jena Fuseki is a service that provides the SPARQL API over HTTP
### END INIT INFO

# DEBUG=1
NAME=fuseki
if [ -f /etc/default/$NAME ]; then
  . /etc/default/$NAME
fi

# simple replacements for LSB daemon logging functions if not defined
# Centos 6 has init-functions but not log_daemon_msg/log_begin_msg/log_end_msg
# Define simple version - attempt to replace with /lib/lsb/init-functions
log_daemon_msg() {
    echo $1
}
log_begin_msg() {
    echo $1
}
log_end_msg() {
    if [ $1 -eq 0 ]; then
	echo '[OK]'
    else
	echo '[failed]'
    fi
}

if [ -f /lib/lsb/init-functions ]; then
    . /lib/lsb/init-functions
fi

usage()
{
  echo "Usage: ${0##*/} {start|stop|restart|run|status}"
  exit 1
}

[ $# -gt 0 ] || usage
CMD="$1"

# Utility functions

findDirectory()
{
  local L OP=$1
  shift
  for L in "$@"; do
    [ "$OP" "$L" ] || continue
    printf %s "$L"
    break
  done
}

findFile()
{
  local L F=$1
  shift
  for L in "$@"; do
    [ -f "${L}/${F}" ] || continue
    printf %s "${L}/${F}"
    break
  done
}

running()
{
  local PID=$(cat "$1" 2>/dev/null) || return 1
  ps -p "$PID" >/dev/null 2>&1
}

# Are we running in cygwin?
cygwin=false
case "`uname`" in
    CYGWIN*) cygwin=true;;
esac

# Set FUSKEI_HOME to the script invocation directory if it is not specified
if [ -z "$FUSEKI_HOME" ]
then
  SCRIPT="$0"
  # Catch common issue: script has been symlinked
  if [ -L "$SCRIPT" ]
  then
    SCRIPT="$(readlink "$0")"
    # If link is relative
    case "$SCRIPT" in
      /*) ;; # fine
      *) SCRIPT=$( dirname "$0" )/$SCRIPT;; # fix
    esac
  fi
  # Work out root from script location
  FUSEKI_HOME="$( cd "$( dirname "$SCRIPT" )" && pwd )"
fi

# Deal with Cygwin path issues
if [ "$cygwin" == "true" ]
then
  FUSEKI_HOME=`cygpath -w "$FUSEKI_HOME"`
fi

if [ ! -e "$FUSEKI_HOME" ]
then
  log_daemon_msg "FUSEKI_HOME '$FUSEKI_HOME' does not exist" 1>&2
  exit 1
fi

# Set FUSEKI_BASE
if [ -z "$FUSEKI_BASE" ]
then
  #FUSEKI_BASE="/etc/fuseki"
  FUSEKI_BASE="$FUSEKI_HOME/run"
  # Autocreate FUSEKI_BASE if defaulting to FUSEKI_HOME/run (simple deployment)
  if [ ! -e "$FUSEKI_BASE" ]
  then
      log_daemon_msg "Creating '$FUSEKI_BASE'"
      if [ "$cygwin" == "true" ]
      then
	  FUSEKI_BASE=`cygpath -w "$FUSEKI_BASE"`
      fi
      mkdir "$FUSEKI_BASE"
  fi
fi

if [ "$cygwin" == "true" ]
then
  FUSEKI_BASE=`cygpath -w "$FUSEKI_BASE"`
fi

if [ ! -e "$FUSEKI_BASE" -o ! -d "$FUSEKI_BASE" ]
then
  log_daemon_msg "FUSEKI_BASE '$FUSEKI_BASE' does not exist or is not a directory" 1>&2
  exit 1
fi

if [ ! -w "$FUSEKI_BASE" ]
then
  log_daemon_msg "FUSEKI_BASE '$FUSEKI_BASE' is not writable." 1>&2
  exit 1
fi

# Find a location for the pid file
if [ -z "$FUSEKI_RUN" ]
then
  FUSEKI_RUN=$(findDirectory -w /var/run /usr/var/run $FUSEKI_HOME /tmp)
fi

# Get PID file name
if [ -z "$FUSEKI_PID" ]
then
  FUSEKI_PID="$FUSEKI_RUN/fuseki.pid"
fi

# Log directory
if [ -n "$FUSEKI_LOGS" ]
then
    log_daemon_msg "FUSEKI_LOGS can not be set externally - ignored" 1>&2 
fi
FUSEKI_LOGS="$FUSEKI_BASE/logs"

# Stderr and stdout log
if [ -z "$FUSEKI_LOGS_STDERROUT" ]
then
  FUSEKI_LOGS_STDERROUT="$FUSEKI_LOGS/stderrout.log"
fi

# Set up JAVA if not set
if [ -z "$JAVA" ]
then
    if [ -z "$JAVA_HOME" ]
    then
	JAVA=$(which java)
    else
        JAVA=$JAVA_HOME/bin/java
    fi
fi

if [ -z "$JAVA" ]
then
    (
	echo "Cannot find a Java JDK."
	echo "Please set either set JAVA or JAVA_HOME and put java (>=1.8) in your PATH."
    ) 1>&2
    exit 1
fi

# The location of the start up JAR
FUSEKI_START=${FUSEKI_START:-$FUSEKI_HOME/fuseki-server.jar}

# Deal with Cygwin path issues
if [ "$cygwin" == "true" ]
then
  FUSEKI_START=`cygpath -w "$FUSEKI_START"`
fi

# Some JVM settings
if [ -z "$JAVA_OPTIONS" ]
then
  JAVA_OPTIONS="-Xmx1500M"
fi

# Default Fuseki Arguments
if [ -z "$FUSEKI_ARGS" ]
then
  if [ -z "$FUSEKI_CONF" ]
  then
    FUSEKI_ARGS=""
  else
    FUSEKI_ARGS="--config=$FUSEKI_CONF"
  fi
fi

# -- Run command
## Default: Fuseki server, with UI and admin area.
MAIN="${MAIN:-serverUI}"

## Translate names into Java entry points.
case $MAIN in
    ## Minimal server - no additional features.
    "basic")
	MAIN='org.apache.jena.fuseki.main.cmds.FusekiBasicCmd'
	;;
    ## Server, no UI, no admin work area, only Prometheus and Shiro
    "main")
	MAIN='org.apache.jena.fuseki.main.cmds.FusekiMainCmd'
	;;
    ## Plain server, with Fuseki modules, no UI, no admin work area, with Prometheus and Shiro.
    "server-plain" | "plain")
	MAIN='org.apache.jena.fuseki.main.cmds.FusekiServerPlainCmd'
	;;
    ## Full server, with Fuseki modules, with UI and with an admin work area.
    "serverui"| "server-ui" | "serverUI" )
	MAIN='org.apache.jena.fuseki.main.cmds.FusekiServerUICmd'
	;;
esac
# -- Run command

if [ -z "$FUSEKI_CLASSES" ]
then
  RUN_ARGS=(${JAVA_OPTIONS[@]} -cp "$FUSEKI_START" "$MAIN" "${FUSEKI_ADDITIONAL_ARGS[@]}" $FUSEKI_ARGS)
else
  RUN_ARGS=(${JAVA_OPTIONS[@]} -cp "$FUSEKI_START:$FUSEKI_CLASSES" "$MAIN" "${FUSEKI_ADDITIONAL_ARGS[@]}" $FUSEKI_ARGS)
fi
RUN_CMD=("$JAVA" "${RUN_ARGS[@]}")

# Export the variables to be seen by the java server process.
export FUSEKI_BASE

#####################################################
# Comment these out after you're happy with what
# the script is doing.
#####################################################
if (( DEBUG ))
then
  log_daemon_msg "FUSEKI_HOME    =  $FUSEKI_HOME"
  log_daemon_msg "FUSEKI_BASE    =  $FUSEKI_BASE"
  log_daemon_msg "FUSEKI_CONF    =  $FUSEKI_CONF"
  log_daemon_msg "FUSEKI_RUN     =  $FUSEKI_RUN"
  log_daemon_msg "FUSEKI_PID     =  $FUSEKI_PID"
  log_daemon_msg "FUSEKI_ARGS    =  $FUSEKI_ARGS"
  log_daemon_msg "FUSEKI_START   =  $FUSEKI_START"
  log_daemon_msg "FUSEKI_CLASSES =  $FUSEKI_CLASSES"
  log_daemon_msg "CONFIGS        =  ${CONFIGS[*]}"
  log_daemon_msg "JAVA           =  $JAVA"
  log_daemon_msg "JAVA_OPTIONS   =  ${JAVA_OPTIONS[*]}"
  log_daemon_msg "RUN_ARGS       =  ${RUN_ARGS[@]}"
  log_daemon_msg "RUN_CMD        =  ${RUN_CMD[@]}"
  log_daemon_msg "Stdout/stderr  =  $FUSEKI_LOGS_STDERROUT"
fi

NO_START=${NO_START:-0}

# Life cycle functions
start() {
  if (( NO_START )); then
    log_daemon_msg "Not starting Fuseki - NO_START=1"
    exit
  fi

  # Make sure the data and log directories exist
  mkdir -p "$FUSEKI_LOGS"
  if [ ! -z "$FUSEKI_USER" ]
  then
    chown "$FUSEKI_USER" "$FUSEKI_LOGS"
  fi

  # Make sure the .jar file exists
  if [ ! -e $FUSEKI_START ]; then
    log_daemon_msg "Could not see Fuseki .jar file: \$FUSEKI_START has value '$FUSEKI_START'"
    exit 1
  fi

  log_begin_msg "Starting Fuseki"
  if type start-stop-daemon > /dev/null 2>&1
  then
    unset CH_USER
    if [ -n "$FUSEKI_USER" ]
    then
      CH_USER="--chuid $FUSEKI_USER"
    fi
    if start-stop-daemon --start $CH_USER --chdir "$FUSEKI_HOME" --background --make-pidfile --pidfile "$FUSEKI_PID" --startas /bin/bash -- -c "exec $JAVA ${RUN_ARGS[*]} > $FUSEKI_LOGS_STDERROUT 2>&1"
    then
      sleep 2
      if running "$FUSEKI_PID"
      then
        log_end_msg 0
        print_started
      else
        log_end_msg 1
      fi
    else
      log_end_msg 1
      log_daemon_msg "** start-stop-daemon failed to run"
    fi
  else
    if running $FUSEKI_PID
    then
      log_end_msg 1
      log_daemon_msg 'Already Running!'
      exit 1
    else
      # dead pid file - remove
      rm -f "$FUSEKI_PID"
    fi

# use subshell to cd to FUSKEI_HOME directory and execute
    (cd "$FUSEKI_HOME"
    if [ "$FUSEKI_USER" ]
    then
      touch "$FUSEKI_PID"
      chown "$FUSEKI_USER" "$FUSEKI_PID"
##       if [  "$FUSEKI_LOGS_STDERROUT" != "$FUSEKI_LOGS/stderrout.log" ]]
##       then
## 	  log_daemon_msg "Redirecting Fuseki stderr/stdout to $FUSEKI_LOGS_STDERROUT"
##       fi
      ## su with login, passing over environment variables.
      su - "$FUSEKI_USER" -c "
        export FUSEKI_BASE='${FUSEKI_BASE}'
        export FUSEKI_HOME='${FUSEKI_HOME}'
        exec ${RUN_CMD[*]} &> '$FUSEKI_LOGS_STDERROUT' &
        disown \$!
        echo \$! > '$FUSEKI_PID'"
    else
      exec "${RUN_CMD[@]}" &> "$FUSEKI_LOGS_STDERROUT" &
      disown $!
      echo $! > "$FUSEKI_PID"
    fi
)
    
    log_end_msg 0
    print_started
  fi
}

print_started() {
  log_daemon_msg "STARTED Fuseki `date`"
  log_daemon_msg "PID=$(cat "$FUSEKI_PID" 2>/dev/null)"
}

delete_fuseki_pid_file() {
  rm -f "$FUSEKI_PID"
}

stop() {
  log_begin_msg "Stopping Fuseki: "

  if ! running "$FUSEKI_PID"
  then
    log_end_msg 1

    # if a stop rather than a restart, signal failure to stop
    if [ -z "$1" ]
    then
      exit 1
    fi
  fi

  ###############################################################
  # !!!! This code needs to be improved, too many repeats !!!!  #
  ###############################################################
  if type start-stop-daemon > /dev/null 2>&1; then
    start-stop-daemon --stop --pidfile "$FUSEKI_PID" --chdir "$FUSEKI_HOME" --startas "$JAVA" --signal HUP

    ## Die after a 30 second timeout
    TIMEOUT=30
    while running "$FUSEKI_PID"; do
      if (( TIMEOUT-- == 0 )); then
        start-stop-daemon --stop --pidfile "$FUSEKI_PID" --chdir "$FUSEKI_HOME" --startas "$JAVA" --signal KILL
      fi
        sleep 1
    done
    delete_fuseki_pid_file
    log_end_msg 0
  else
    PID=$(cat "$FUSEKI_PID" 2>/dev/null)
    kill "$PID" 2>/dev/null

    TIMEOUT=30
    while running $FUSEKI_PID; do
      if (( TIMEOUT-- == 0 )); then
        kill -KILL "$PID" 2>/dev/null
      fi
      sleep 1
    done
    delete_fuseki_pid_file
    log_end_msg 0
  fi
}


# Run in the foreground, as the current user
run() {
  # Make sure the .jar file exists
  if [ ! -e $FUSEKI_START ]; then
    log_daemon_msg "Could not see Fuseki .jar file: \$FUSEKI_START has value '$FUSEKI_START'"
    exit 1
  fi
  exec "${RUN_CMD[@]}"
}

case $CMD in
  start)
    start
  ;;
  stop)
    stop
  ;;
  restart)
    stop "restarting"
    start
  ;;
  run)
    run
  ;;
  status)
    if running $FUSEKI_PID
    then
      PID=`cat "$FUSEKI_PID"`
      log_daemon_msg "Fuseki is running with pid: $PID"
    else
      log_daemon_msg "Fuseki is not running"
    fi
  ;;
  *)
    usage
  ;;
esac

exit 0
