#!/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
#------------------------------------------------------------------------------
set -u

# Change the first three variables below to match the volume names on the machine
# you are configuring the SDP on.
# Set the remaining variables appropriately. The meaning of each should be obvious.
# Before running this script, create a configuration file.  You can use a
# single configuration file named mkdirs.cfg in the same directory as this
# mkdirs.sh script. Alternately, you can create a file named mkdirs.N.cfg,
# where 'N' is the name of the instance you intend to configure.
#
# Run this script as root, and pass in the instance number you are configuring.
#
# If you do not have root access, then some commands will be skipped, and you
# will need to have the defined $P4DIR directory already existing (created by
# the root user and the ownership changed to the OS user that you are planning
# to run Perforce under). The /hxmetadata*, /hxdepots and /hxlogs volumes will
# also need to be owned by the OS user as well in order for the script to work.
# You can then run this script as the OS user for Perforce and everything
# should work fine.
#
# This script creates an init script in the $P4DIR/$SDP_INSTANCE/bin directory.
# You can use it from there if you are configuring a cluster, or you can link
# it in /etc/init.d if you are setting up a stand alone machine.  Sample
# systemd service files are included in the systemd folder.
#
# After running this script, set up the crontab based on templates
# generated in $P4DIR/common/etc/cron.d.  For convenience, a sample generated
# is to $P4DIR/p4.crontab.
#
# Next, put the license file in place in the P4ROOT dir, and launch the server with the init
# script.
#
# Then run $P4DIR/common/bin/p4master_run <instance> $P4DIR/common/bin/live_checkpoint.sh
# and then run both the daily_checkpoint.sh and recreate_db_checkpoint.sh to
# make sure everything is working before setting up the crontab.
#
# Also run $P4DIR/common/bin/p4master_run <instance> $P4DIR/common/bin/p4review.py <instance>
# to make sure the review script is working properly.  If you intend to use
# Swarm, you can skip configuration of the review daemon, and instead configure
# Swarm to handle review-style email notifications.
#
# UPGRADING SDP
# Specify the -test parameter to the script.
# In this case the script will NOT make the various directories under $P4DIR,
# but will instead create /tmp/p4 directory structure with the various files
# processed via templates etc. You can then manually compare this directory
# structure with your existing $P4DIR structure and manually copy the various
# files into it.

function msg () { echo -e "$*"; }
function errmsg () { msg "\\nError: (line: ${BASH_LINENO[0]}) $*" >&2; }
function warnmsg () { msg "\\nWarning: (line: ${BASH_LINENO[0]}) $*"; }
function bail() { errmsg "(line: ${BASH_LINENO[0]}) ${1:-Unknown Error}\n" >&2; exit "${2:-1}"; }
function usage () {
   msg "Usage:\\n\\t${0##*/} <instance> [-test]\\n"
   exit 1
}

declare -i DoChownCommands=1

if [ $# -lt 1 ] || [ $# -gt 2 ]; then
   usage
fi

# Verify instance value.
SDP_INSTANCE=$1
if [[ "$SDP_INSTANCE" == "-test" ]]; then
    bail "An instance argument is required."
fi

# Note that if the following is set to 1 then a trial run is done, into /tmp/p4
TEST=0
if [[ $# -gt 1 && "$2" == "-test" ]]; then
   TEST=1
fi

# Check for config file - same dir as this script
if [[ -r "${0%/*}/mkdirs.${SDP_INSTANCE}.cfg" ]]; then
   mkdirs_config="${0%/*}/mkdirs.${SDP_INSTANCE}.cfg"
elif [[ -r "${0%/*}/mkdirs.cfg" ]]; then
   mkdirs_config="${0%/*}/mkdirs.cfg"
else
   bail "Missing mkdirs config file $mkdirs_config."
fi

# shellcheck disable=SC1090
source "$mkdirs_config" || bail "Failed to source $mkdirs_config."

if [[ -r $SDP/Version ]]; then
   # shellcheck disable=SC2086
   SDP_VERSION="$(cat $SDP/Version)"
else
   SDP_VERSION="Rev. SDP/Unix/UNKNOWN"
fi

P4DIR=/p4
P4SERVER="p4_$SDP_INSTANCE"

export AWK=awk
export ID=id
export MAIL=mail

OS=$(uname)
if [[ "${OS}" = "SunOS" ]] ; then
  export AWK=/usr/xpg4/bin/awk
  export ID=/usr/xpg4/bin/id
  export MAIL=mailx
elif [[ "${OS}" = "AIX" ]] ; then
  export AWK=awk
  export ID=id
  export MAIL=mail
fi

if [[ $($ID -u) -eq 0 ]]; then
   msg "Verified: Running as root."
elif [[ $(whoami) == "$OSUSER" ]]; then
   warnmsg "Not running as root; chown commands will be skipped and basic directories must exist.\n"
   DoChownCommands=0
else
   bail "$0 must be run as as root or $OSUSER.\n"
fi

if [[ $TEST -eq 1 ]]; then
   # CN has prefix
   CN=/tmp
   DB1=tmp/hxmetadata1
   DB2=tmp/hxmetadata2
   DD=tmp/hxdepots
   LG=tmp/hxlogs
   mkdir -p /$DB1 /$DB2 /$DD /$LG
   P4DIR=/tmp/p4
   msg "\n*********  -test specified - will install to $P4DIR  *********\n"
fi

SDP_COMMON=$SDP/Server/Unix/p4/common

declare -i PreflightOK=1

[[ -f $SDP_COMMON/bin/p4 ]] || { errmsg "No p4 in $SDP_COMMON/bin"; PreflightOK=0; }
[[ -f $SDP_COMMON/bin/p4d ]] || { errmsg "No p4d in $SDP_COMMON/bin"; PreflightOK=0; }
[[ -f $SDP_COMMON/bin/p4p ]] || warnmsg "No p4p in $SDP_COMMON/bin"
[[ -f $SDP_COMMON/bin/p4broker ]] || warnmsg "No p4broker in $SDP_COMMON/bin"

if [[ $TEST -eq 1 && ! -d "$P4DIR" ]]; then
   mkdir "$P4DIR" || bail "Failed to create $P4DIR."
fi

# If we aren't running as root, extend the preflight checks to verify basic dirs
# exist.
if [[ $($ID -u) -ne 0 && $TEST -eq 0 ]]; then
   for d in "$P4DIR" "/$DD" "/$DB1" "/$DB2" "/$LG"; do
      if [[ -d "$d" ]]; then
         # shellcheck disable=SC2012 disable=SC2016
         dirOwner=$(ls -ld "$d" | $AWK '{print $3}')
         # shellcheck disable=SC2012 disable=SC2016
         dirGroup=$(ls -ld "$d" | $AWK '{print $4}')
         if [[ "$dirOwner" != "$OSUSER" ]]; then
            errmsg "Dir [$d] exists but with wrong owner, $dirOwner instead of $OSUSER."
            PreflightOK=0
         fi
         if [[ "$dirGroup" != "$OSGROUP" ]]; then
            warnmsg "Dir [$d] exists but with wrong group, $dirGroup instead of $OSGROUP."
         fi
      else
         errmsg "Dir must exist if not running as root: $d"
         PreflightOK=0
      fi
   done
fi

if [[ $PreflightOK -eq 1 ]]; then
   msg "Verified: Preflight checks passed."
else
   bail "Aborting due to failed preflight checks."
fi

chmod 755 "$SDP_COMMON/bin/p4"
chmod 700 "$SDP_COMMON/bin/p4d"

[[ -f "$SDP_COMMON/bin/p4broker" ]] && chmod 700 "$SDP_COMMON/bin/p4broker"
[[ -f "$SDP_COMMON/bin/p4web" ]] && chmod 700 "$SDP_COMMON/bin/p4web"
[[ -f "$SDP_COMMON/bin/p4p" ]] && chmod 700 "$SDP_COMMON/bin/p4p"

# Make sure you update the p4 and p4d to the latest versions in the
# sdp/Server/Unix/p4/common/bin directory when making new instances at a later date.

# shellcheck disable=SC2016
P4RELNUM=$("$SDP_COMMON/bin/p4" -V | grep -i Rev. | $AWK -F / '{print $3}')
# shellcheck disable=SC2016
P4BLDNUM=$("$SDP_COMMON/bin/p4" -V | grep -i Rev. | $AWK -F / '{print $4}' | $AWK '{print $1}')
# shellcheck disable=SC2016
P4DRELNUM=$("$SDP_COMMON/bin/p4d" -V | grep -i Rev. | $AWK -F / '{print $3}')
# shellcheck disable=SC2016
P4DBLDNUM=$("$SDP_COMMON/bin/p4d" -V | grep -i Rev. | $AWK -F / '{print $4}' | $AWK '{print $1}')

[[ -d "$P4DIR" ]] || mkdir "$P4DIR"

[[ -d "/$DD/p4" ]] || mkdir "/$DD/p4"
[[ -d "/$DB1/p4" ]] || mkdir "/$DB1/p4"
[[ -d "/$DB2/p4" ]] || mkdir "/$DB2/p4"
[[ -d "/$LG/p4" ]] || mkdir "/$LG/p4"

mkdir -p "/$LG/p4/$SDP_INSTANCE/tmp"
mkdir -p "/$DD/p4/$SDP_INSTANCE/depots"
mkdir -p "/$DD/p4/$SDP_INSTANCE/checkpoints"

case "$SERVER_TYPE" in
   (p4d_standby)
      mkdir -p "/$LG/p4/$SDP_INSTANCE/journals.rep"
      if [[ $DoChownCommands -eq 1 ]]; then
         chown "$OSUSER:$OSGROUP" "/$LG/p4/$SDP_INSTANCE/journals.rep"
      fi
   ;;
   (p4d_replica|p4d_edge|p4d_ha)
      mkdir -p "/$DD/p4/$SDP_INSTANCE/checkpoints.${REPLICA_ID#p4d_}"
      if [[ $DoChownCommands -eq 1 ]]; then
         chown "$OSUSER:$OSGROUP" "/$DD/p4/$SDP_INSTANCE/checkpoints.${REPLICA_ID#p4d_}"
      fi
   ;;
esac

[[ -d "$P4DIR/ssl" ]] || mkdir -p "$P4DIR/ssl"
[[ -f "$SDP/Server/Unix/p4/ssl/config.txt" && ! -f "$P4DIR/ssl/config.txt" ]] &&\
    cp "$SDP/Server/Unix/p4/ssl/config.txt" "$P4DIR/ssl/"

if [[ "$CN" == "" ]]; then
    # When blank we put on "local" drive
    [[ -d "$P4DIR/common/bin" ]] || mkdir -p "$P4DIR/common/bin"
    [[ -d "$P4DIR/common/config" ]] || mkdir -p "$P4DIR/common/config"
else
    # (default) put it on hxdepots or where specified
    [[ -d "$CN/p4/common" ]] || mkdir -p "$CN/p4/common"
    [[ -L "$P4DIR/common" ]] || ln -s "$CN/p4/common" "$P4DIR/common"
    [[ -d "$CN/p4/common/bin" ]] || mkdir -p "$CN/p4/common/bin"
    [[ -d "$CN/p4/common/config" ]] || mkdir -p "$CN/p4/common/config"
fi

mkdir -p "/$DB1/p4/$SDP_INSTANCE/db1/save"
mkdir -p "/$DB2/p4/$SDP_INSTANCE/db2/save"
mkdir -p "/$LG/p4/$SDP_INSTANCE/logs"

cd "/$DD/p4/$SDP_INSTANCE" || bail "Could not cd to /$DD/p4/$SDP_INSTANCE"

# Create /p4/1 on local disk as a directory
# Then the links within it
cd "$P4DIR" || bail "Could not cd to $P4DIR"
[[ -d "$SDP_INSTANCE" ]] || mkdir "$SDP_INSTANCE"
cd "$SDP_INSTANCE" || bail "Could not cd to $SDP_INSTANCE"

[[ -d bin ]] || mkdir bin
[[ -L root ]] || ln -s "/$DB1/p4/$SDP_INSTANCE/db1" root
[[ -L offline_db ]] || ln -s "/$DB2/p4/$SDP_INSTANCE/db2" offline_db
if [[ ! -d logs ]]; then
   # shellcheck disable=SC2226
   [[ -L logs ]] || ln -s "/$LG/p4/$SDP_INSTANCE/logs"
fi
# shellcheck disable=SC2226
[[ -L depots ]] || ln -s "/$DD/p4/$SDP_INSTANCE/depots"
# shellcheck disable=SC2226
[[ -L checkpoints ]] || ln -s "/$DD/p4/$SDP_INSTANCE/checkpoints"
# shellcheck disable=SC2226
[[ -L tmp ]] || ln -s "/$LG/p4/$SDP_INSTANCE/tmp"

case "$SERVER_TYPE" in
   (p4d_standby)
      # shellcheck disable=SC2226
      [[ -L journals.rep ]] || ln -s "/$LG/p4/$SDP_INSTANCE/journals.rep"
   ;;
   (p4d_replica|p4d_edge|p4d_ha)
      # shellcheck disable=SC2226
      [[ -L "checkpoints.${REPLICA_ID#p4d_}" ]] || ln -s "/$DD/p4/$SDP_INSTANCE/checkpoints.${REPLICA_ID#p4d_}"
esac

[[ -L sdp ]] || ln -s "$SDP" "$P4DIR/sdp"

case "$SERVER_TYPE" in
   (p4d_master|p4d_edge)
      SERVERID="$MASTER_ID"
      echo "$SERVERID" > "$P4DIR/$SDP_INSTANCE/root/server.id"
   ;;
   (p4d_replica|p4d_standby)
      SERVERID="$REPLICA_ID"
      echo "$SERVERID" > "$P4DIR/$SDP_INSTANCE/root/server.id"
   ;;
   (*)
      SERVERID="$SERVER_TYPE"
   ;;
esac

[[ -f "$P4DIR/common/bin/p4_$P4RELNUM.$P4BLDNUM" ]] || cp "$SDP_COMMON/bin/p4" "$P4DIR/common/bin/p4_$P4RELNUM.$P4BLDNUM"
[[ -f "$P4DIR/common/bin/p4d_$P4DRELNUM.$P4DBLDNUM" ]] || cp "$SDP_COMMON/bin/p4d" "$P4DIR/common/bin/p4d_$P4DRELNUM.$P4DBLDNUM"

if [[ ! -f "$P4DIR/common/bin/p4_vars" ]]; then
   cp -R "$SDP_COMMON"/bin/* "$P4DIR/common/bin"

   # Copy certain subdirs of /p4/common if don't already exist.
   for dir in etc hms lib; do
      if [[ ! -d "$P4DIR/common/$dir" ]]; then
         cp -pr "$SDP_COMMON/$dir" "$P4DIR/common/."
      fi
   done

   cd "$P4DIR/common/bin" || bail "Could not cd to $P4DIR/common/bin"
   ln -s "p4_$P4RELNUM.$P4BLDNUM" "p4_${P4RELNUM}_bin"
   ln -s "p4d_$P4DRELNUM.$P4DBLDNUM" "p4d_${P4DRELNUM}_bin"
   ln -s "p4_${P4RELNUM}_bin" "p4_bin"

   sed -e "s:REPL_SDPVERSION:${SDP_VERSION}:g" \
      -e "s/REPL_OSUSER/${OSUSER}/g" \
      "$SDP_COMMON/config/p4_vars.template" > p4_vars
fi

cd "$P4DIR/common/bin" || bail "Could not cd to $P4DIR/common/bin"

ln -s "p4d_${P4DRELNUM}_bin" "p4d_${SDP_INSTANCE}_bin"

if [[ ! -e "$P4DIR/common/config/.p4passwd.${P4SERVER}.admin" ]]; then
   echo "$P4ADMINPASS" > "$P4DIR/common/config/.p4passwd.${P4SERVER}.admin"
else
   warnmsg "Skipping update of existing admin password file $P4DIR/common/config/.p4passwd.${P4SERVER}.admin"
fi

if [[ ! -e "$P4DIR/common/config/.p4passwd.${P4SERVER}.service" ]]; then
   echo "$P4SERVICEPASS" > "$P4DIR/common/config/.p4passwd.${P4SERVER}.service"
else
   warnmsg "Skipping update of existing service password file $P4DIR/common/config/.p4passwd.${P4SERVER}.service"
fi

# Create broker links if broker exists
if [[ -f "$SDP_COMMON/bin/p4broker" ]]; then
   # shellcheck disable=SC2016
   P4BRELNUM=$("$SDP_COMMON/bin/p4broker" -V | grep -i Rev. | $AWK -F / '{print $3}')
   # shellcheck disable=SC2016
   P4BBLDNUM=$("$SDP_COMMON/bin/p4broker" -V | grep -i Rev. | $AWK -F / '{print $4}' | $AWK '{print $1}')
   [[ -f "$P4DIR/common/bin/p4broker_$P4BRELNUM.$P4BBLDNUM" ]] || cp "$SDP_COMMON/bin/p4broker" "$P4DIR/common/bin/p4broker_$P4BRELNUM.$P4BBLDNUM"
   [[ -L "p4broker_${P4BRELNUM}_bin" ]] && unlink "p4broker_${P4BRELNUM}_bin"
   ln -s "p4broker_$P4BRELNUM.$P4BBLDNUM" "p4broker_${P4BRELNUM}_bin"
   [[ -L "p4broker_${SDP_INSTANCE}_bin" ]] && unlink "p4broker_${SDP_INSTANCE}_bin"
   ln -s "p4broker_${P4BRELNUM}_bin" "p4broker_${SDP_INSTANCE}_bin"
   cd "$P4DIR/$SDP_INSTANCE/bin" || \
      bail "Could not cd to $P4DIR/$SDP_INSTANCE/bin"
   [[ -L "p4broker_${SDP_INSTANCE}" ]] || ln -s "$P4DIR/common/bin/p4broker_${SDP_INSTANCE}_bin" "p4broker_${SDP_INSTANCE}"
   sed "s/REPL_SDP_INSTANCE/${SDP_INSTANCE}/g" "$SDP_COMMON/etc/init.d/p4broker_instance_init.template" > "p4broker_${SDP_INSTANCE}_init"
   chmod +x "p4broker_${SDP_INSTANCE}_init"
fi

# Create p4p links if p4p exists
cd "$P4DIR/common/bin" || bail "Could not cd to $P4DIR/common/bin"
if [[ -x "$SDP_COMMON/bin/p4p" ]]; then
   # shellcheck disable=SC2016
   P4PRELNUM=$("$SDP_COMMON/bin/p4p" -V | grep -i Rev. | $AWK -F / '{print $3}')
   # shellcheck disable=SC2016
   P4PBLDNUM=$("$SDP_COMMON/bin/p4p" -V | grep -i Rev. | $AWK -F / '{print $4}' | $AWK '{print $1}')
   [[ -f "$P4DIR/common/bin/p4p_$P4PRELNUM.$P4PBLDNUM" ]] || cp "$SDP_COMMON/bin/p4p" "$P4DIR/common/bin/p4p_$P4PRELNUM.$P4PBLDNUM"
   [[ -L "p4p_${P4PRELNUM}_bin" ]] && unlink "p4p_${P4PRELNUM}_bin"
   ln -s "p4p_$P4PRELNUM.$P4PBLDNUM" "p4p_${P4PRELNUM}_bin"
   [[ -L "p4p_${SDP_INSTANCE}_bin" ]] && unlink "p4p_${SDP_INSTANCE}_bin"
   ln -s "p4p_${P4PRELNUM}_bin" "p4p_${SDP_INSTANCE}_bin"
   cd "$P4DIR/$SDP_INSTANCE/bin" || \
      bail "Could not cd to $P4DIR/$SDP_INSTANCE/bin"

   [[ -L "p4p_${SDP_INSTANCE}" ]] || ln -s "$P4DIR/common/bin/p4p_${SDP_INSTANCE}_bin" "p4p_${SDP_INSTANCE}"
   sed -e "s/REPL_SDP_INSTANCE/${SDP_INSTANCE}/g" \
      -e "s/REPL_DNSNAME/${P4DNSNAME}/g" \
      "$SDP_COMMON/etc/init.d/p4p_instance_init.template" > "p4p_${SDP_INSTANCE}_init"
   chmod +x "p4p_${SDP_INSTANCE}_init"
   mkdir -p "/$DD/p4/$SDP_INSTANCE/cache"
fi

cd "$P4DIR/$SDP_INSTANCE/bin" || bail "Could not cd to $P4DIR/$SDP_INSTANCE/bin" 
ln -s "$P4DIR/common/bin/p4_bin" "p4_$SDP_INSTANCE"

sed "s/REPL_SDP_INSTANCE/${SDP_INSTANCE}/g" \
   "$SDP_COMMON/etc/init.d/p4d_instance_init.template" > "p4d_${SDP_INSTANCE}_init"
chmod +x "p4d_${SDP_INSTANCE}_init"

# Moved the less commonly used, but always created init scripts to an init directory.
mkdir init
cd init || bail "Could not cd to $PWD/init"

sed "s/REPL_SDP_INSTANCE/${SDP_INSTANCE}/g" \
   "$SDP_COMMON/etc/init.d/p4dtg_instance_init.template" > "p4dtg_${SDP_INSTANCE}_init"
chmod +x "p4dtg_${SDP_INSTANCE}_init"

cd .. || bail "Could not cd to .. from $PWD"

if [[ $CASE_SENSITIVE -eq 1 ]]; then
   ln -s "$P4DIR/common/bin/p4d_${SDP_INSTANCE}_bin" "p4d_$SDP_INSTANCE"
else
   echo '#!/bin/bash' > "p4d_$SDP_INSTANCE"
   echo "P4D=/p4/common/bin/p4d_${SDP_INSTANCE}_bin" >> "p4d_$SDP_INSTANCE"
   # shellcheck disable=SC2016
   echo 'exec $P4D -C1 "$@"' >> "p4d_$SDP_INSTANCE"
   chmod +x "p4d_$SDP_INSTANCE"
fi

cd "$P4DIR/common/config" || bail "Could not cd to $P4DIR/common/config"

sed -e "s/REPL_MAILTO/${MAILTO}/g" \
   -e "s/REPL_MAILFROM/${MAILFROM}/g" \
   -e "s/REPL_ADMINUSER/${ADMINUSER}/g" \
   -e "s/REPL_MASTER_ID/${MASTER_ID}/g" \
   -e "s/REPL_SSLPREFIX/${SSL_PREFIX}/g" \
   -e "s/REPL_P4PORT/${P4_PORT}/g" \
   -e "s/REPL_P4BROKERPORT/${P4BROKER_PORT}/g" \
   -e "s/REPL_P4WEBPORT/${P4WEB_PORT}/g" \
   -e "s/REPL_P4FTPPORT/${P4FTP_PORT}/g" \
   -e "s/REPL_DNSNAME/${P4DNSNAME}/g" \
   -e "s/REPL_P4P_TARGET_PORT/${P4P_TARGET_PORT}/g" \
   "$SDP_COMMON/config/instance_vars.template" > "p4_${SDP_INSTANCE}.vars"

sed -e "s/REPL_ADMINISTRATOR/${MAILTO}/g" \
   -e "s/REPL_COMPLAINFROM/${COMPLAINFROM}/g" \
   -e "s/REPL_MAILHOST/${MAILHOST}/g" \
   -e "s/REPL_DNSNAME/${P4DNSNAME}/g" \
   "$SDP_COMMON/config/p4review.cfg.template" > "p4_${SDP_INSTANCE}.p4review.cfg"

cd "$P4DIR" || bail "Could not cd to $P4DIR"

if [[ ! -f "${P4DIR}/p4.crontab" ]]; then
   CRONTAB_NAME=p4.crontab
else
   CRONTAB_NAME=p4.crontab.new
   rm -f "${P4DIR}/$CRONTAB_NAME" > /dev/null 2>&1
   msg "Existing crontab found, writing new crontab to ${P4DIR}/${CRONTAB_NAME}"
fi

sed -e "s/REPL_MAILTO/${MAILTO}/g" \
   -e "s/REPL_MAILFROM/${MAILFROM}/g" \
   -e "s/REPL_INSTANCE/${SDP_INSTANCE}/g" \
   "$SDP_COMMON/etc/cron.d/template.crontab.combined" > "$CRONTAB_NAME"

cd "$P4DIR/${SDP_INSTANCE}/bin" || \
   bail "Could not cd to $P4DIR/${SDP_INSTANCE}/bin"

if [[ "$SHAREDDATA" == "TRUE" ]]; then
   if [[ "$SERVER_TYPE" == p4d_replica || "$SERVER_TYPE" == p4d_standby || "$SERVER_TYPE" == p4d_ha ]]; then
      msg "Configuring Replica sharing depot data with master, skipping chown/chmod of depot files"
      DoChownCommands=0
   fi
fi

if [[ $DoChownCommands -eq 1 ]]; then
   if [[ $TEST -eq 0 ]]; then
      chown "$OSUSER:$OSGROUP" "/$DD"
      chown "$OSUSER:$OSGROUP" "/$LG"
      chown "$OSUSER:$OSGROUP" "/$DB1"
      chown "$OSUSER:$OSGROUP" "/$DB2"
   fi
   chown "$OSUSER:$OSGROUP" "/$DD/p4"
   chown "$OSUSER:$OSGROUP" "/$LG/p4"
   chown "$OSUSER:$OSGROUP" "/$DB1/p4"
   chown "$OSUSER:$OSGROUP" "/$DB2/p4"

   chown -h "$OSUSER:$OSGROUP" "$P4DIR"
   chown -h "$OSUSER:$OSGROUP" "$P4DIR/$SDP_INSTANCE"
   chown -h "$OSUSER:$OSGROUP" "$P4DIR/common"
   [[ $TEST -eq 0 ]] && chown -h "$OSUSER:$OSGROUP" "$P4DIR/sdp"
   chown "$OSUSER:$OSGROUP" "$P4DIR/*"

   chown -Rh "$OSUSER:$OSGROUP" "$P4DIR/common/"
   [[ $TEST -eq 0 ]] && chown -Rh "$OSUSER:$OSGROUP" "$P4DIR/sdp"
   chown -Rh "$OSUSER:$OSGROUP" "$P4DIR/common"
   chown -Rh "$OSUSER:$OSGROUP" "/$DB1/p4/$SDP_INSTANCE"
   chown -Rh "$OSUSER:$OSGROUP" "/$DB2/p4/$SDP_INSTANCE"
   chown -Rh "$OSUSER:$OSGROUP" "/$LG/p4/$SDP_INSTANCE"

   if [[ "$SHAREDDATA" == "FALSE" ]]; then
      msg "Setting ownership on depot files - this may take some time ..."
      chown -Rh "$OSUSER:$OSGROUP" "/$DD/p4/$SDP_INSTANCE"
   fi

   chown -Rh "$OSUSER:$OSGROUP" "$P4DIR/$SDP_INSTANCE/bin"
else
   msg "Skipped chown/chmod commands for large directory trees."
fi

chmod 700 "/$DB1/p4"
chmod 700 "/$DB2/p4"
chmod 700 "/$DD/p4"
chmod 700 "/$LG/p4"

chmod -R 700 "/$DB1/p4/$SDP_INSTANCE"
chmod -R 700 "/$DB2/p4/$SDP_INSTANCE"
chmod -R 700 "$P4DIR/common"
chmod -R 700 "/$LG/p4/$SDP_INSTANCE"

if [[ "$SHAREDDATA" == "FALSE" ]]; then
   msg "Setting permissions on depot files - this may take some time ..."
   chmod -R 700 "/$DD/p4/$SDP_INSTANCE"
fi

if [[ "$SDP_INSTANCE" != "$MASTERINSTANCE" ]]; then
   if [[ -f "$P4DIR/$MASTERINSTANCE/root/license" ]]; then
      ln -s "$P4DIR/$MASTERINSTANCE/root/license" "$P4DIR/$SDP_INSTANCE/root/license"
      chown -h "$OSUSER:$OSGROUP" "$P4DIR/$SDP_INSTANCE/root/license"
   fi
fi

chmod 755 "$P4DIR/${SDP_INSTANCE}"/bin/*_init
chmod 755 "$P4DIR/${SDP_INSTANCE}"/bin/init/*_init
chmod 600 "$P4DIR/common/config/.p4passwd.${P4SERVER}.admin"
chmod 600 "$P4DIR/common/config/.p4passwd.${P4SERVER}.service"
find $P4DIR/common/bin/ -name "*.cfg" -exec chmod 600 {} \;
find $P4DIR/common/bin/ -name "*.html" -exec chmod 600 {} \;
chmod 700 $P4DIR/ssl
find $P4DIR/ssl/ -type f -exec chmod 600 {} \;

if [[ $TEST -eq 1 ]]; then
   msg "
This was done in TEST mode - please run the following command to see any changes should be
applied to your live environment (manually):

diff -r /p4/$SDP_INSTANCE/bin $P4DIR/$SDP_INSTANCE/bin
diff -r /p4/common $P4DIR/common

If upgrading an older SDP version then be careful to ensure files in /p4/common/config are correct
and update that /p4/common/bin/p4_vars is appropriate.\n"
fi

exit 0