#!/bin/bash
#==============================================================================
# Copyright and license info is available in the LICENSE file included with
# the Server Deployment Package (SDP), and also available online:
# https://swarm.workshop.perforce.com/projects/perforce-software-sdp/view/main/LICENSE
#------------------------------------------------------------------------------

# Helix Proxy base init script

# Do nothing unless $SDP_INSTANCE is defined.
export SDP_INSTANCE="${1:-Unset}"
export OS_INIT_MECHANISM="${OS_INIT_MECHANISM:-Unset}"
declare ThisScript=${0##*/}
declare Version=5.1.1
declare CmdLine="$0 $*"
declare -i StartDelay=2
declare -i ExitCode=0
declare -i UseSystemd=0
declare ServiceName=
declare OpMode="${2:-usage}"
declare ProxyServerArgs=
declare Log=
declare StraceEnabledFile=
declare StracePidFile=
declare StraceLog=

if [[ $SDP_INSTANCE == Unset ]]; then
   echo -e "\nError: The SDP_INSTANCE is not defined.\n."
   exit 1
fi

# Load SDP controlled shell environment.
# shellcheck disable=SC1091
source /p4/common/bin/p4_vars "$SDP_INSTANCE"
ExitCode=$?

if [[ "$ExitCode" -ne 0 ]]; then
   echo -e "\nError: Failed to load SDP environment for instance $SDP_INSTANCE.\n"
   exit 1
fi

# shellcheck disable=SC1090 disable=SC1091
source "$P4CBIN/ps_functions.sh"
ExitCode=$?

if [[ "$ExitCode" -ne 0 ]]; then
   echo -e "\nError: Failed to load SDP ps_functions.sh lib.\n"
   exit 1
fi

# shellcheck disable=SC1091
source "$P4CLIB/strace.lib"

Log="$LOGS/p4p_init.log"

if [[ $(id -u) -eq 0 ]]; then
   exec su - "$OSUSER" -c "$0 $*"
elif [[ $(id -u -n) != "$OSUSER" ]]; then
   echo "$0 can only be run by root or $OSUSER"
   exit 1
fi

if [[ ! -x "$P4PBIN" ]]; then
   echo -e "\nError: $P4PBIN is not executable."
   exit 2;
fi

# ServiceName is derived from the binary name. Set it unconditionally here so
# it is always available (e.g. for strace file naming) even on systems without
# systemd. The systemctl block below uses the same value.
ServiceName="${P4PBIN##*/}"

# Determine if systemd is configured for this instance.
if [[ -n "$(command -v systemctl)" ]]; then
   # We use the systemctl 'is-enabled' test because that can be used without sudo
   # regardless of the permissions on the systemd unit *.service file. This
   # systemd behavior is consistent across Linux distros.  It doesn't matter if
   # the service is enabled or not (which affects whether it starts on boot).
   # The trick is that we're just checking for any stdout.  The output will be
   # 'enabled' or 'disabled' if there's a systemd unit file for the service,
   # even if you don't have permissions to do a 'systemctl cat'.  If the service
   # isn't defined at all -- that's what we're checking for -- nothing goes to
   # stdout (we discard the stderr). So the -n test on the stdout reliably
   # indicates whether systemd configured for the service or not.
   ServiceName="${P4PBIN##*/}"
   if [[ -n "$(systemctl is-enabled "$ServiceName" 2>/dev/null)" ]]; then
      UseSystemd=1
      MustUseSystemdMsg="\nError: It appears an attempt was made to start or stop the $ServiceName\nservice without using systemd. When a systemd unit file is configured, only the\nsystemd init mechanism can be used to start and stop the service, so that\nsystemd maintains a more reliable indication of the status of the service. Run\nas root or as $OSUSER with sudo. For example:\n\n\tsudo systemctl start $ServiceName\n\tsudo systemctl stop $ServiceName\n\tsystemctl status $ServiceName\n\nNote that the 'status' check does not require sudo.\n\nThe systemd unit file is:\n\n<<<<<<<<\n$(sudo systemctl cat "$ServiceName")\n>>>>>>>\n\nIf you used 'systemctl' and still got this message, then please check if OS_INIT_MECHANISM is defined\nin the above file. See /p4/sdp/Server/Unix/setup/systemd/p4d_1.service for an example."
   fi
fi

#------------------------------------------------------------------------------
# Override P4LOG value from p4_vars to be suitable for a proxy server.
export P4LOG="$LOGS/p4p.log"

# These variables are used as globals inside strace.lib, not directly here.
# shellcheck disable=SC2034
StraceEnabledFile="$LOGS/.strace.$ServiceName"
# shellcheck disable=SC2034
StracePidFile="$LOGS/.strace.$ServiceName.pid"
# shellcheck disable=SC2034
StraceLog="$LOGS/strace.$ServiceName.log"

# Build ProxyServerArgs, with some conditional logic. Start with required flags.
ProxyServerArgs+="-p $PROXY_PORT -t $PROXY_TARGET -r $P4PCACHE -L $P4LOG"

# Add user-specified '-v' and other options defined as PROXY_V_FLAGS in the
# Instance Config file.
if [[ -n "${PROXY_V_FLAGS:-}" ]]; then
   ProxyServerArgs+=" ${PROXY_V_FLAGS}"
fi

# Ensure proxy.monitor.level is set to a reasonable default if not
# explicitly defined in the environment.
[[ "${ProxyServerArgs:-}" =~ proxy.monitor.level ]] || \
   ProxyServerArgs+=" -v proxy.monitor.level=${PROXY_MON_LEVEL:-3}"

# Use the '-d' option to do process forking unless running with systemd,
# in which case we do not use '-d' and let systemd handle the process
# forking.
[[ "$UseSystemd" -eq 1 ]] || ProxyServerArgs+=" -d"

echo -e "\n$(date) Called $ThisScript v$Version with command line:\n$CmdLine" >> "$Log"

case "$OpMode" in
   (start)
      if [[ "$UseSystemd" -eq 1 && "$OS_INIT_MECHANISM" != "systemd" ]]; then
         echo -e "$MustUseSystemdMsg"
         exit 1
      fi

      # Delay start $StartDelay seconds.
      if [[ "${SDP_START_DELAY:-}" =~ ^[0-9]+$ ]]; then
         StartDelay="$SDP_START_DELAY"
      fi

      echo "Delaying p4p start for $StartDelay seconds." | tee -a "$Log"
      sleep "$StartDelay"

      if [[ "$PROXY_TARGET" =~ ^ssl[46]*: ]]; then
         # Quietly attempt a trust of the target server. This might fail if the
         # target server is not reachable, but it doesn't hurt to try.
         echo "${P4BIN}" -p "$PROXY_TARGET" trust -f -y
         "${P4BIN}" -p "$PROXY_TARGET" trust -f -y > /dev/null 2>&1
      fi

      # shellcheck disable=SC2164
      cd "$P4PCACHE"
      if [[ -n "$(command -v ulimit)" && "$(ulimit -c)" != "0" ]]; then
         ulimit -c unlimited
      fi

      echo -e "\n$(date) Starting ${P4PBIN} ${ProxyServerArgs}" | tee -a "$Log"
      if [[ -e "$StraceEnabledFile" && "$UseSystemd" -eq 1 ]]; then
         # Wrap mode (systemd): strace runs the proxy as its child, capturing
         # every syscall from the very first instruction.
         # shellcheck disable=SC2086
         run_service_under_strace "${P4PBIN}" ${ProxyServerArgs}
      else
         if [[ -e "$StraceEnabledFile" ]]; then
            # Attach mode (non-systemd best effort): strace attaches after the
            # proxy starts. Early startup syscalls may be missed. disown keeps
            # the watcher alive after the script exits.
            attach_strace_if_requested "get_pids \"$P4PBIN\"" &
            disown
         fi
         # shellcheck disable=SC2086
         "${P4PBIN}" ${ProxyServerArgs}
      fi
   ;;

   (status)
      p4p_pids=$(get_pids "$P4PBIN")
      if [[ -n "$p4p_pids" ]]; then
         echo "${P4PBIN} is running as pids: $p4p_pids."

         # Quietly attempt a trust of the local proxy port.
         if [[ "$PROXY_PORT" =~ ^ssl[46]*: ]]; then
            "${P4BIN}" -p "$PROXY_PORT" trust -f -y > /dev/null 2>&1
         fi

         exit 0
      else
         echo "${P4PBIN} is NOT running."
         exit 1
      fi
   ;;

   (stop)
      p4p_pids=$(get_pids "$P4PBIN")

      if [[ -n "$p4p_pids" ]]; then
         if [[ "$UseSystemd" -eq 1 && "$OS_INIT_MECHANISM" != "systemd" ]]; then
            echo -e "$MustUseSystemdMsg"
            exit 1
         fi

         while [[ -n "$p4p_pids" ]]; do
            echo "Shutting down ${P4PBIN} pids: $p4p_pids." | tee -a "$Log"
            # shellcheck disable=SC2086
            kill $p4p_pids 2>&1 | $GREP -v -i "No such"
            sleep 1
            p4p_pids=$(get_pids "$P4PBIN")
         done
         echo "${P4PBIN} stopped." | tee -a "$Log"
         stop_strace_if_running
         exit 0
      else
         echo "${P4PBIN} was NOT running." | tee -a "$Log"
         exit 1
      fi
   ;;
   (restart)
      $0 "$SDP_INSTANCE" stop
      $0 "$SDP_INSTANCE" start
   ;;
   (*)
      echo -e "\nUsage: $0 SDP_INSTANCE {start|stop|status|restart}\n"
      exit 1
   ;;
esac