p4broker_base #17

#!/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 Broker 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.2
declare CmdLine="$0 $*"
declare -i StartDelay=2
declare -i ExitCode=0
declare -i UseSystemd=0
declare ServiceName=
declare P4BrokerFlags=
declare TargetPort=
declare ListenPort=
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/p4broker_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 "$P4BROKERBIN" ]]; then
   echo -e "\nError: $P4BROKERBIN is not executable."
   exit 2;
fi

declare OpMode=${2:-usage}
declare ConfigTag=${3:-default}
declare ConfigTagList=
declare -i ExitStatus=0

if [[ "$ConfigTag" == "all" ]]; then
   # shellcheck disable=SC2164 disable=SC2012
   ConfigTagList="default $(cd "${P4CCFG}"; ls "${P4SERVER}".broker.*.cfg 2>/dev/null | cut -d '.' -f 3)"
   # shellcheck disable=SC2116
   ConfigTagList=$(echo "$ConfigTagList")
else
   ConfigTagList=$ConfigTag
fi

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

for tag in $ConfigTagList; do
   if [[ "$tag" == "default" ]]; then
      ServiceName="${P4BROKERBIN##*/}"
      if [[ -r "/p4/common/config/${P4SERVER}.broker.${HOSTNAME%%.*}.cfg" ]]; then
         export P4BROKERCFG="${P4CCFG}/${P4SERVER}.broker.${HOSTNAME%%.*}.cfg"
      else
         export P4BROKERCFG="${P4CCFG}/${P4SERVER}.broker.cfg"
      fi
   else
      ServiceName="${P4BROKERBIN##*/}_${tag}"
      export P4BROKERCFG="${P4CCFG}/${P4SERVER}.broker.${tag}.cfg"
   fi

   # Determine if systemd is configured for this instance and config.
   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.
      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$(sudo systemctl cat "$ServiceName")"
      else
         UseSystemd=0
      fi
   fi

   if [[ ! -r "$P4BROKERCFG" ]]; then
      echo -e "\nError: Missing broker config file $P4BROKERCFG.\n"
      ExitStatus=1
      continue
   fi

   # Set flags to start the broker referencing the config file.
   P4BrokerFlags="-d -c $P4BROKERCFG"

   # If running with systemd, we drop the '-d' flag and let systemd handle the
   # process forking.
   if [[ "$UseSystemd" -eq 1 ]]; then
      P4BrokerFlags="${P4BrokerFlags/-d / }"
   fi

   # Set strace file paths; ServiceName may include tag suffix for non-default configs.
   # 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"

   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 broker start for $StartDelay seconds." | tee -a "$Log"
         sleep "$StartDelay"

         # Grab the first target port from the broker config file.
         TargetPort=$(grep -E '^\s*target\s*=' "$P4BROKERCFG"|head -1)
         TargetPort=${TargetPort#*=}
         TargetPort=${TargetPort%;}
         TargetPort=${TargetPort// /}

         if [[ "$TargetPort" =~ ^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.
            "${P4BIN}" -p "$TargetPort" trust -f -y > /dev/null 2>&1
         fi

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

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

      status)
         p4broker_pids=$(get_pids "$P4BROKERCFG")
         if [[ -n "$p4broker_pids" ]]; then
            echo "${P4BROKERBIN} ($tag config) is running as pids: $p4broker_pids."

            # Grab the listen port from the broker config file.
            ListenPort=$(grep -E '^\s*listen\s*=' "$P4BROKERCFG"|head -1)
            ListenPort=${ListenPort#*=}
            ListenPort=${ListenPort%;}
            ListenPort=${ListenPort// /}

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

            ExitStatus=0
         else
            echo "${P4BROKERBIN} ($tag config) is NOT running."
            ExitStatus=1
         fi
      ;;

      stop)
         p4broker_pids=$(get_pids "$P4BROKERCFG")

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

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

exit $ExitStatus