mkdirs.sh #70

#!/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
#------------------------------------------------------------------------------
#
# 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.
# 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.

set -u

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

source $mkdirs_config || bail "Failed to source $mkdirs_config."

if [[ -r $SDP/Version ]]; then
   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
  DD=tmp
  MD=tmp
  LG=tmp
  # 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
         dirOwner=$(ls -ld "$d" | $AWK '{print $3}')
         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.

P4RELNUM=`$SDP_COMMON/bin/p4 -V | grep -i Rev. | $AWK -F / '{print $3}'`
P4BLDNUM=`$SDP_COMMON/bin/p4 -V | grep -i Rev. | $AWK -F / '{print $4}' | $AWK '{print $1}'`
P4DRELNUM=`$SDP_COMMON/bin/p4d -V | grep -i Rev. | $AWK -F / '{print $3}'`
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)
        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" == "/tmp" ]]; then
    [[ -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
else
    [[ -d $P4DIR/common/bin ]] || mkdir -p $P4DIR/common/bin
    [[ -d $P4DIR/common/config ]] || mkdir -p $P4DIR/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

# Create /p4/1 on local disk as a directory
# Then the links within it
cd $P4DIR
[[ -d $SDP_INSTANCE ]] || mkdir $SDP_INSTANCE
cd $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
    [[ -L logs ]] || ln -s /$LG/p4/$SDP_INSTANCE/logs
fi
[[ -L depots ]] || ln -s /$DD/p4/$SDP_INSTANCE/depots
[[ -L checkpoints ]] || ln -s /$DD/p4/$SDP_INSTANCE/checkpoints
[[ -L tmp ]] || ln -s /$LG/p4/$SDP_INSTANCE/tmp

case "$SERVER_TYPE" in
    (p4d_standby)
        [[ -L journals.rep ]] || ln -s /$LG/p4/$SDP_INSTANCE/journals.rep
    ;;
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
   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

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
   P4BRELNUM=`$SDP_COMMON/bin/p4broker -V | grep -i Rev. | $AWK -F / '{print $3}'`
   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
   [[ -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
if [[ -x $SDP_COMMON/bin/p4p ]]; then
   P4PRELNUM=`$SDP_COMMON/bin/p4p -V | grep -i Rev. | $AWK -F / '{print $3}'`
   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
   [[ -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
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

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 ..

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
   echo 'exec $P4D -C1 "$@"' >> p4d_$SDP_INSTANCE
   chmod +x p4d_$SDP_INSTANCE
fi

cd $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
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

if [[ "$SHAREDDATA" == "TRUE" ]]; then
   if [[ "$SERVER_TYPE" == p4d_replica || "$SERVER_TYPE" == p4d_standby ]]; 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
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
[[ -e $P4DIR/common/bin/*.cfg ]] && chmod 600 $P4DIR/common/bin/*.cfg
[[ -e $P4DIR/common/bin/*.html ]] && chmod 600 $P4DIR/common/bin/*.html
chmod 700 $P4DIR/ssl
[[ -e $P4DIR/ssl/* ]] && chmod 600 $P4DIR/ssl/*

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