#!/bin/sh ############################################################################### # WebSphere Application Server liberty launch script # # Copyright IBM Corp. 2011, 2021 # The source code for this program is not published or other- # wise divested of its trade secrets, irrespective of what has # been deposited with the U.S. Copyright Office. # # ---------------------------------------------------------------------------- # # To customize the use of this script (for example with /etc/init.d system # service managers), use the following environment variables: # # JAVA_HOME - The java executable is found in ${JAVA_HOME}/bin # # JVM_ARGS - A list of JVM command line options, # e.g. system properties or -X parameters # The value will be expanded by the shell (use quotes for spaces) # # LOG_DIR - The log file directory # The default value is ${WLP_OUTPUT_DIR}/serverName/logs # # LOG_FILE - The log file name # This log file is only used if the server is run in the # background via the start action. # The default value is console.log # # PID_DIR - The directory that should be used for server pid file(s). # The default value is ${WLP_OUTPUT_DIR}/.pid # # PID_FILE - The file that should be used for the server pid file. # The default value is ${PID_DIR}/serverName.pid # # WLP_USER_DIR - The user/custom configuration directory used to store # shared and server-specific configuration. # See README.TXT for details about shared resource locations. # A server's configuration is at ${WLP_USER_DIR}/servers/serverName # The default value is the usr directory in the install directory. # # WLP_OUTPUT_DIR - The directory containing output files for defined servers. # This directory must have both read and write permissions for # the user or users that start servers. # By default, a server's output logs and workarea are stored # in the ${WLP_USER_DIR}/servers/serverName directory # (alongside configuration and applications). # If this variable is set, the output logs and workarea # would be stored in ${WLP_OUTPUT_DIR}/serverName. # # WLP_DEBUG_ADDRESS - The port to use when running the server in debug mode. # The default value is 7777. # # WLP_DEBUG_SUSPEND - Whether to suspend the jvm on startup or not. This can be # set to y to suspend the jvm on startup until a debugger attaches, # or set to n to startup without waiting for a debugger to attach. # The default value is y. # # WLP_DEBUG_REMOTE - Whether to allow remote debugging or not. This can be set # to y to allow remote debugging. By default, this value is not # defined, which does not allow remote debugging on newer JDK/JREs. # # WLP_SKIP_UMASK - Skip setting the umask value to allow the default value # to be used. # # WLP_ZOS_PROCEDURE - The name of the STC procedure to be used to start the # server in a z/OS environment. # # WLP_ZOS_JOBNAME - The job name to use when starting the server in # a z/OS environment. # ############################################################################### SERVER_UNKNOWN_STATUS=5 ## ## Determine the platform and absolute path of the installation directory. ## case $OSTYPE in cygwin) uname=CYGWIN_NT # Determine the installation directory without forking if possible. Use # eval to hide ${var//find/replace}, ${var%suffix}, and ${var:first:length} # syntaxes from shells that can't parse them. eval ' # cd to the install directory. savePWD=$PWD script=${0//\\/\/} unset CDPATH; cd "${script%/*}"/.. # Convert the install (current working) directory to a Windows path. case $PWD in /cygdrive/?/*) # Use ${var:first:length} to avoid forking for cygpath. WLP_INSTALL_DIR=${PWD:10:1}:${PWD:11} ;; *) WLP_INSTALL_DIR=`cygpath -ma .` esac cd "$savePWD" ' ;; *) uname=`uname` case $uname in CYGWIN_*) WLP_INSTALL_DIR=`cygpath -ma "${0}"/../..` ;; *) dirname=`dirname "$0"` WLP_INSTALL_DIR=`unset CDPATH; cd "$dirname/.." && pwd` esac esac ## ## Platform specific setup ## PS_P='ps -p' UMASK_O='umask o=' tryShellExtensions=true os400lib=false shareclassesCacheDirPerm=true defaultFileEncoding= newline=' ' nativeEBCDIC=false case ${uname} in CYGWIN_*) # java.exe is a non-Cygwin process, so we need to pass -W. PS_P='ps -W -p' shareclassesCacheDirPerm=false ;; OS/390) defaultFileEncoding=iso8859-1 nativeEBCDIC=true # Auto-convert server.env/jvm.options from ASCII-to-EBCDIC, if necessary. _BPXK_WLM_PROPAGATE=NO # Prevent WLM enclave propagation to spawned processes _EDC_PTHREAD_YIELD=-2 # Disable sleeps inside of pthread_yield JAVA_PROPAGATE=NO # Prevent WLM enclave propagation to new threads export _BPXK_WLM_PROPAGATE _EDC_PTHREAD_YIELD JAVA_PROPAGATE WLP_NLS_PATH="${WLP_INSTALL_DIR}/lib/native/zos/s390x/nls/%N.cat" if [ ${NLSPATH} ] then NLSPATH="${WLP_NLS_PATH}:${NLSPATH}" else NLSPATH="${WLP_NLS_PATH}" fi ;; OS400) # Avoid issues with qsh. tryShellExtensions=false # os400lib gets unset later if we cannot find WAS_PRODUCT_LIB and WAS_SHARED_LIB os400lib=true # on os400 use 'umask -S o=', not 'umask o=' UMASK_O='umask -S o=' ;; esac ## ## safeEcho: Portable echo that can handle backslashes and leading dashes. safeEcho() { cat < /dev/null; then # The shell has support. Define the functions using eval, again to hide the # syntax from shells that don't support it. eval " escapeForEval() { escapeForEvalResult=\\'\${1//\\'/\\'\\\"\\'\\\"\\'}\\' } extractValueAndEscapeForEval() { escapeForEval \"\${1#*=}\" } substitutePrefixVar() { case \$1 in @\$2@*) substitutePrefixVarResult=\$3\${1#@\$2@};; *) substitutePrefixVarResult=\$1 esac } " else ## ## escapeForEval: Escape the first parameter to be safe for use in eval, ## and set escapeForEvalResult with the result. ## escapeForEval() { escapeForEvalResult=\'`safeEcho "$1" | sed s/\'/\'\"\'\"\'/g`\' } ## ## extractValueAndEscapeForEval: Extract the value of a var=value string, ## and set escapeForEvalResult with the result. ## extractValueAndEscapeForEval() { escapeForEvalResult=\'`safeEcho "$1" | sed -e 's/[^=]*=//' -e s/\'/\'\"\'\"\'/g`\' } ## ## substitutePrefixVar: If $1 has a prefix @$2@, set substitutePrefixVarResult ## to $1 with the prefix replaced by $3. Otherwise, set ## to $1. substitutePrefixVar() { case $1 in @$2@*) substitutePrefixVarResult=$3`safeEcho "$1" | sed -e "s/^@$2@//"`;; *) substitutePrefixVarResult=$1 esac } fi ## ## Quote ${WLP_INSTALL_DIR} for eval. ## escapeForEval "${WLP_INSTALL_DIR}" WLP_INSTALL_DIR_QUOTED=${escapeForEvalResult} READ_ETC=1 ## ## Consume script parameters: ## action is required/positional, ## serverName is optional, --options following ## if [ $# -lt 1 ] then ACTION=help:usage else ACTION=$1 shift #consume if [ $# -ge 1 ] then # Only use if it isn't something that looks like an option case $1 in --*);; *) SERVER_NAME=$1 shift #consume esac fi fi ## ## Set server name and directory ## if [ -z "$SERVER_NAME" ] then SERVER_NAME=defaultServer fi ## ## Set JAVA_AGENT_QUOTED if WLP_SKIP_BOOTSTRAP_AGENT is unset. ## JAVA_AGENT_QUOTED=-javaagent:${WLP_INSTALL_DIR_QUOTED}/bin/tools/ws-javaagent.jar if [ -n "${WLP_SKIP_BOOTSTRAP_AGENT}" ]; then JAVA_AGENT_QUOTED= fi ## ## createServer: Function to launch server create ## createServer() { javaCmd '' "${SERVER_NAME}" --create "$@" rc=$? if [ $rc = 0 ]; then rmIfExist "${X_PID_FILE}" if $os400lib; then # If production on IBM i, authorize QEJBSVR to the server folder chgautOS400 "${WLP_USER_DIR}/servers/${SERVER_NAME}" "*RX" chgautOS400 "${WLP_OUTPUT_DIR}" "*RWX" if [ -d "${WLP_USER_DIR}/servers/${SERVER_NAME}/apps" ]; then chgautOS400 "${WLP_USER_DIR}/servers/${SERVER_NAME}/apps" "*RWX" fi fi fi return $rc } ## ## chgautOS400: Change authorization of directory or file $1 to $2 for QEJBSVR. ## This should only be called if $os400lib is true ## chgautOS400() { system "CHGAUT OBJ('$1') USER(QEJBSVR) DTAAUT($2) OBJAUT(*ALL) SUBTREE(*ALL)" } ## ## mkdirs: Create a directory and all parent directories, if necessary. ## mkdirs() { if [ ! -d "$1" ]; then mkdir -p "$1" if $os400lib; then chgautOS400 "$1" "*RWX" fi fi } ## ## rmIfExist: Remove files if they exist. ## rmIfExist() { for file do # [ is a builtin command for most shells, so a fork is not required. if [ -f "${file}" ]; then # If any file exists, pass all files so we only fork once. rm -f "$@" return fi done } ## ## touchIfNotExist: Create an empty file. ## touchIfNotExist() { if [ ! -f "$1" ]; then # true is a builtin command for most shells, so a fork is not required. true > "$1" if $os400lib; then chgautOS400 "$1" "*RWX" fi fi } ## ## serverStatus: Check for a running server process. If the first argument is ## true, avoid using the launcher to verify the status if possible, ## and don't output messages even if the launcher is used. ## The second argument is the --status variant. ## If success is returned, then ${PID} will be set if available. serverStatus() { if [ -f "${SERVER_OUTPUT_DIR}/workarea/.sLock" ]; then if [ ! -f "${SERVER_OUTPUT_DIR}/workarea/.sCommand" ]; then # Workarea exists, .sCommand doesn't. Server is not running. rmIfExist "${X_PID_FILE}" return 1 fi # Read the PID file to set ${PID} if possible. Remove it if stale. # Otherwise, assume the server is started if we're avoiding the launcher. if serverPIDStatus && $1; then return 0 fi # The workarea suggests a started server. Either the script started a # server process that ended before removing .sCommand, or the server was # started without using the script (so the PID file was never created). # In either case, verify the status using the launcher. if $1; then javaCmd '' "${SERVER_NAME}" $2 > /dev/null else javaCmd '' "${SERVER_NAME}" --pid="${PID}" $2 fi rc=$? if [ $rc = 1 ]; then # The launcher verified the server is not running. Remove the indicator # files to avoid checking again on subsequent script invocations. rm -f "${SERVER_OUTPUT_DIR}/workarea/.sCommand" fi return $rc fi if serverPIDStatus; then if $1; then return 0 fi # PID file suggests a started server with a removed workspace. Verify # using the launcher. javaCmd '' "${SERVER_NAME}" --pid-file="${X_PID_FILE}" --pid="${PID}" $2 return $? fi # Neither workarea nor PID file suggest a started server. return 1 } ## ## serverPIDStatus: Check the PID file for a running server process. ${PID} ## will be set to the PID if running or to empty if not. serverPIDStatus() { if [ -f "${X_PID_FILE}" ]; then PID=`cat "${X_PID_FILE}"` if $PS_P "$PID" > /dev/null 2>&1; then return 0 fi rm "${X_PID_FILE}" fi PID= return 1 } ## ## checkServer: Check for created/existing server. If it does not, issue an ## error message if the first argument is true, and then exit the ## script regardless. checkServer() { if [ -d "${SERVER_CONFIG_DIR}" ] || [ "defaultServer" = "${SERVER_NAME}" ] then return 0 fi if $1 then javaCmd '' --message:info.serverNotExist "${SERVER_NAME}" rc=$? if [ $rc = 0 ] then rc=1 fi else rc=1 fi return $rc } ## ## installEnv: Set variables for a non-server or nonexistent server command. installEnv() { readServerEnv "${WLP_INSTALL_DIR}/etc/server.env" installEnvDefaults serverEnvDefaults } ## ## installEnvDefaults: Set variable defaults for a non-server or nonexistent ## server command. installEnvDefaults() { readServerEnv "${WLP_INSTALL_DIR}/java/java.env" readServerEnv "${WLP_INSTALL_DIR}/etc/default.env" if [ -z "${WLP_USER_DIR}" ] then if [ -z "${WLP_DEFAULT_USER_DIR}" ] then WLP_DEFAULT_USER_DIR=${WLP_INSTALL_DIR}/usr fi WLP_USER_DIR=${WLP_DEFAULT_USER_DIR} fi if [ -z "${WLP_OUTPUT_DIR}" ] then if [ -z "${WLP_DEFAULT_OUTPUT_DIR}" ] then WLP_DEFAULT_OUTPUT_DIR=${WLP_USER_DIR}/servers fi WLP_OUTPUT_DIR=${WLP_DEFAULT_OUTPUT_DIR} fi SERVER_CONFIG_DIR=${WLP_USER_DIR}/servers/${SERVER_NAME} if $os400lib then if [ -z "${WAS_PRODUCT_LIB}" ] || [ -z "${WAS_SHARED_LIB}" ] then os400lib=false fi fi export WLP_USER_DIR export WLP_OUTPUT_DIR } ## ## serverEnvDefaults: Set defaults for server variables. serverEnvDefaults() { SERVER_OUTPUT_DIR=${WLP_OUTPUT_DIR}/${SERVER_NAME} # Unset set/tested variables to prevent collisions with nested process invocations if [ -z "$LOG_DIR" ] then X_LOG_DIR=${SERVER_OUTPUT_DIR}/logs else X_LOG_DIR=${LOG_DIR} unset LOG_DIR fi export X_LOG_DIR if [ -z "$LOG_FILE" ] then X_LOG_FILE=console.log else X_LOG_FILE=${LOG_FILE} unset LOG_FILE fi export X_LOG_FILE if [ -z "$PID_DIR" ]; then X_PID_DIR=${WLP_OUTPUT_DIR}/.pid else X_PID_DIR=${PID_DIR} unset PID_DIR fi if [ -z "$PID_FILE" ]; then X_PID_FILE=${X_PID_DIR}/${SERVER_NAME}.pid else X_PID_FILE=${PID_FILE} X_PID_DIR=`dirname "${X_PID_FILE}"` unset PID_FILE fi if [ -z "${JAVA_HOME}" ] then if [ -z "${JRE_HOME}" ] then if [ -z "${WLP_DEFAULT_JAVA_HOME}" ] then # Use whatever java is on the path JAVA_CMD=java else substitutePrefixVar "${WLP_DEFAULT_JAVA_HOME}" WLP_INSTALL_DIR "${WLP_INSTALL_DIR}" JAVA_HOME=${substitutePrefixVarResult} JAVA_CMD=${JAVA_HOME}/bin/java fi else JAVA_HOME=${JRE_HOME} JAVA_CMD=${JRE_HOME}/bin/java fi else if [ -f "${JAVA_HOME}/jre/bin/java" ] then JAVA_CMD=${JAVA_HOME}/jre/bin/java else JAVA_CMD=${JAVA_HOME}/bin/java fi fi # Prefer OPENJ9_JAVA_OPTIONS to deprecated IBM_JAVA_OPTIONS if [ -z "${OPENJ9_JAVA_OPTIONS}" ] then SPECIFIED_JAVA_OPTIONS=${IBM_JAVA_OPTIONS} else SPECIFIED_JAVA_OPTIONS=${OPENJ9_JAVA_OPTIONS} fi # Command-line parsing of -Xshareclasses does not allow "," in cacheDir. case ${WLP_OUTPUT_DIR} in *,*) SERVER_IBM_JAVA_OPTIONS=${SPECIFIED_JAVA_OPTIONS} ;; *) if ( echo "${SPECIFIED_JAVA_OPTIONS}" | grep -q "Xshareclasses"); then SERVER_IBM_JAVA_OPTIONS=${SPECIFIED_JAVA_OPTIONS} else # Set -Xscmx if [ "${ACTION}" = "debug" ] then XSCMX_VAL="130m" else XSCMX_VAL="80m" fi if $shareclassesCacheDirPerm then SERVER_IBM_JAVA_OPTIONS="-Xshareclasses:name=liberty-%u,nonfatal,cacheDir=\"${WLP_OUTPUT_DIR}/.classCache\",cacheDirPerm=1000 -XX:ShareClassesEnableBCI -Xscmx${XSCMX_VAL} ${SPECIFIED_JAVA_OPTIONS}" else SERVER_IBM_JAVA_OPTIONS="-Xshareclasses:name=liberty-%u,nonfatal,cacheDir=\"${WLP_OUTPUT_DIR}/.classCache\" -XX:ShareClassesEnableBCI -Xscmx${XSCMX_VAL} ${SPECIFIED_JAVA_OPTIONS}" fi fi esac # Add -Xquickstart -Xshareclasses:none for client JVMs only. We don't want # shared classes cache created for client operations. # Add -Dcom.ibm.tools.attach.enable=yes to allow self-attach on z/OS IBM_JAVA_OPTIONS="-Xquickstart -Dcom.ibm.tools.attach.enable=yes ${SPECIFIED_JAVA_OPTIONS} -Xshareclasses:none" export IBM_JAVA_OPTIONS OPENJ9_JAVA_OPTIONS="-Xquickstart -Dcom.ibm.tools.attach.enable=yes ${SPECIFIED_JAVA_OPTIONS} -Xshareclasses:none" export OPENJ9_JAVA_OPTIONS # Set a default file encoding if needed if [ -n "$defaultFileEncoding" ]; then if ! expr "${JVM_OPTIONS_QUOTED} ${JVM_ARGS} ${SPECIFIED_JAVA_OPTIONS}" : '.*\(-Dfile\.encoding\=[^[:space:]]\)' > /dev/null; then JVM_ARGS="${JVM_ARGS} -Dfile.encoding=$defaultFileEncoding" fi fi serverUmask } ## ## serverEnv: Set variables for an existing server. serverEnv() { readServerEnv "${WLP_INSTALL_DIR}/etc/server.env" installEnvDefaults readServerEnv "${WLP_USER_DIR}/shared/server.env" readServerEnv "${SERVER_CONFIG_DIR}/server.env" serverEnvDefaults } ## ## serverEnvAndJVMOptions: Read server.env files and set environment variables. ## Read jvm.options file into ${JVM_OPTIONS_QUOTED} serverEnvAndJVMOptions() { serverEnv # Avoids HeadlessException on all platforms and Liberty JVMs appearing as applications and stealing focus on Mac. # Declare allowAttachSelf=true so that the VM will permit a late self attach if localConnector-1.0 is enabled JVM_OPTIONS_QUOTED="-Djava.awt.headless=true -Djdk.attach.allowAttachSelf=true" SERVER_JVM_OPTIONS_QUOTED=${JVM_OPTIONS_QUOTED} rc=0 # The order of merging the jvm.option files sets the precedence. # Once a given jvm option is set, it will be overridden if a duplicate # is seen later. They will both be written in to the options parameter # but the last one written will take precedence. If none are read # the script will try to read the jvm.options in etc TEMP_SAVED_OPTIONS=$SERVER_JVM_OPTIONS_QUOTED mergeJVMOptions "${WLP_USER_DIR}/shared/jvm.options" if [ $rc -ne 0 ]; then return $rc fi # This location is intentionally not documented but removing might break existing installations mergeJVMOptions "${WLP_INSTALL_DIR}/usr/shared/jvm.options" if [ $rc -ne 0 ]; then return $rc fi mergeJVMOptions "${SERVER_CONFIG_DIR}/configDropins/defaults/jvm.options" if [ $rc -ne 0 ]; then return $rc fi mergeJVMOptions "${SERVER_CONFIG_DIR}/jvm.options" if [ $rc -ne 0 ]; then return $rc fi mergeJVMOptions "${SERVER_CONFIG_DIR}/configDropins/overrides/jvm.options" if [ $rc -ne 0 ]; then return $rc fi # If none of the four files above are seen we will check for an options # file in the etc folder. if [ $READ_ETC -eq 1 ]; then SERVER_JVM_OPTIONS_QUOTED=$TEMP_SAVED_OPTIONS mergeJVMOptions "${WLP_INSTALL_DIR}/etc/jvm.options" fi JPMS_MODULE_FILE_LOCATION="${JAVA_HOME}/lib/modules" if [ -z "${JAVA_HOME}" ]; then JPMS_MODULE_FILE_LOCATION=$(dirname $(dirname $(which java)))/lib/modules fi # If we are running on Java 9, apply Liberty's built-in java 9 options if [ -f "${JPMS_MODULE_FILE_LOCATION}" ]; then mergeJVMOptions "${WLP_INSTALL_DIR}/lib/platform/java/java9.options" fi return $rc } mergeJVMOptions() { jvmOptions=$1 if [ -f "$jvmOptions" ]; then READ_ETC=0 saveIFS=$IFS IFS=$newline for option in `readNativeFile "$jvmOptions" '[#-]' | tr -d '\r'`; do if [ -n "$option" ]; then case $option in \#*);; *) escapeForEval "${option}" SERVER_JVM_OPTIONS_QUOTED="${SERVER_JVM_OPTIONS_QUOTED} '${option}'" ;; esac fi done IFS=$saveIFS fi } ## ## readServerEnv: Read server.env file and export environment variables. readServerEnv() { if [ -f "$1" ]; then saveIFS=$IFS IFS=$newline for line in `readNativeFile "$1" '[#_A-Za-z=]' | tr -d '\r'`; do case $line in \#*);; *=*) # Only accept alphanumeric variable names to avoid eval complexities. if var=`safeEcho "$line" | sed -e 's/^\([a-zA-Z0-9_][a-zA-Z0-9_]*\)=.*/\1/'`; then case $var in *=*) SERVER_ENV_SETUP_FAILURE="${var} ${SERVER_ENV_SETUP_FAILURE}" ;; *) extractValueAndEscapeForEval "${line}" eval "${var}=${escapeForEvalResult}; export ${var}" ;; esac fi esac done IFS=$saveIFS fi } ## ## Detects the code page of the file and converts to EBCDIC, ## if necessary, before cat'ing. ## ## Only applicable if running in a native EBCDIC environment (z/OS). ## ## $1 the file name ## $2 pattern denoting the expected first char of file readNativeFile() { if ${nativeEBCDIC}; then # ASCII 'm' overlaps with EBCDIC '_', so strip it out before detecting the codepage. # Note: cat used here to handle ASCII-tagged files. filecontents=`cat "$1" | iconv -f ISO8859-1 -t IBM-1047 | tr -d 'm\r\n'` case $filecontents in $2*) iconv -f ISO8859-1 -t IBM-1047 "$1" ;; # ASCII file. *) cat "$1" # EBCDIC file or ASCII-tagged file. esac else cat "$1" fi } ## ## serverWorkingDirectory: Change the working directory to ${SERVER_OUTPUT_DIR} serverWorkingDirectory() { # Change the working directory to ${SERVER_OUTPUT_DIR}. mkdirs "${SERVER_OUTPUT_DIR}" cd "${SERVER_OUTPUT_DIR}" } ## set the umask value to remove all permissions for the Other category ## but leave existing values for User and Group unaltered ## ## If the WLP_SKIP_UMASK variable is set then do not set umask serverUmask() { if [ -z "${WLP_SKIP_UMASK}" ]; then $UMASK_O fi } ## ## javaCmd: Execute a java-based command. Arguments are: ## ## backgroundLogFile ## Non-empty path for output log if the process should be created in the ## background; empty otherwise. Directory must exist. ## ## "$@" ## All remaining arguments to be passed to the command ## ## The following variables must be set: ## ${JAVA_CMD} - the java command ## ${JAVA_DEBUG} - JVM options to enable debug, or empty ## ${JAVA_AGENT_QUOTED} - The -javaagent argument quoted for eval ## ${JVM_OPTIONS_QUOTED} - jvm.options quoted for eval ## ${WLP_INSTALL_DIR_QUOTED} - ${WLP_INSTALL_DIR} quoted for eval javaCmd() { JAVA_CMD_LOG=$1 shift # Filter all of the -D and -X arguments off of the argument line and add them to $JVM_OPTIONS_QUOTED REMAINING_ARGS="" for option in "$@"; do if [ -n "${option}" ]; then if [ -z "${option##-D*}" ] || [ -z "${option##-X*}" ]; then JVM_OPTIONS_QUOTED="$JVM_OPTIONS_QUOTED '$option'" elif [ -z "$REMAINING_ARGS" ] ; then REMAINING_ARGS="$option" else REMAINING_ARGS="$REMAINING_ARGS $option" fi else REMAINING_ARGS="$REMAINING_ARGS $option" fi done # Set all the parameters for the java command. We use eval so that each line # in jvm.options is treated as a distinct argument. eval "set -- ${JAVA_AGENT_QUOTED} ${JVM_OPTIONS_QUOTED} ${JAVA_DEBUG} ${JVM_ARGS} -jar ${WLP_INSTALL_DIR_QUOTED}/bin/tools/ws-server.jar ""$REMAINING_ARGS" ARGS="$@" # Do not add extra logic after the commands without preserving $? if [ -n "${JAVA_CMD_LOG}" ]; then rmIfExist "${JAVA_CMD_LOG}" "${JAVA_CMD}" "$@" >> "${JAVA_CMD_LOG}" 2>&1 & elif [ $ACTION = "run" ] || [ $ACTION = "debug" ] ; then exec "${JAVA_CMD}" "$@" else "${JAVA_CMD}" "$@" fi } ## ## Issue a translated warning message. The java command will use the same options as javaCmd, ## but will ignore debug settings and will not exit after running the command when 'run' ## or 'debug' is used ## ## "$@" ## All arguments passed to the java command ## issueMessage() { # Set all the parameters for the java command. We use eval so that each line # in jvm.options is treated as a distinct argument. eval "set -- ${JAVA_AGENT_QUOTED} ${JVM_OPTIONS_QUOTED} ${JVM_ARGS} -jar ${WLP_INSTALL_DIR_QUOTED}/bin/tools/ws-server.jar "'"$@"' ARGS="$@" "${JAVA_CMD}" "$@" } ## ## serverCmdOS400: Launch a server process using the OS400 native launcher. ## ## backgroundLogFile ## Non-empty path for output log if the process should be created in the ## background; empty otherwise. Directory must exist. ## ## "$@" ## All remaining arguments to be passed to the command ## ## The following variables must be set: ## ${JAVA_CMD} - the java command ## ${JAVA_DEBUG} - JVM options to enable debug, or empty ## ${JAVA_AGENT_QUOTED} - The -javaagent argument quoted for eval ## ${JVM_OPTIONS_QUOTED} - jvm.options quoted for eval ## ${WLP_INSTALL_DIR_QUOTED} - ${WLP_INSTALL_DIR} quoted for eval serverCmdOS400() { SERVER_CMD_OS400_BACKGROUND_LOG=$1 shift eval "set -- -jvmargs ${JAVA_AGENT_QUOTED} ${JVM_OPTIONS_QUOTED} ${JAVA_DEBUG} ${JVM_ARGS} -jar ${WLP_INSTALL_DIR_QUOTED}/bin/tools/ws-server.jar "'"$@"' export JAVA_HOME if [ -n "${SERVER_CMD_OS400_BACKGROUND_LOG}" ] then "/QSYS.LIB/${WAS_PRODUCT_LIB}.LIB/QWLPSTRSVR.PGM" \ -pgm "${WAS_PRODUCT_LIB}/QWLPSTRSVR" \ -server "${SERVER_NAME}" \ -sharedlib "${WAS_SHARED_LIB}" \ -pidfile "${X_PID_FILE}" \ -background \ -logdir "${X_LOG_DIR}" \ -serveroutputdir "${SERVER_OUTPUT_DIR}" \ -serverlog "${SERVER_CMD_OS400_BACKGROUND_LOG}" \ "$@" else "/QSYS.LIB/${WAS_PRODUCT_LIB}.LIB/QWLPSTRSVR.PGM" \ -logdir "${X_LOG_DIR}" \ -serveroutputdir "${SERVER_OUTPUT_DIR}" \ "$@" fi } ## ## serverCmd: Launch a server process. ## ## backgroundLogFile ## Non-empty path for output log if the process should be created in the ## background; empty otherwise. Directory must exist. ## ## PID will be set if the process is launched in the background and the return ## code is 0. ## serverCmd() { ## If one or more variables in server.env contains non-alphanumeric characters ## SERVER_ENV_SETUP_FAILURE will contain the invalid entries. We have to ## temporarily set ACTION to 'start' so that the process will not exit after ## the error message when ACTION is 'run' or 'debug' if [ -n "${SERVER_ENV_SETUP_FAILURE}" ]; then for i in ${SERVER_ENV_SETUP_FAILURE}; do issueMessage --message:warning.variable.invalid "$i" done fi SERVER_CMD_BACKGROUND_LOG=$1 shift ## On OS400, we need to create the defaultServer first from this script ## to get all the permissions correct. If we allow the server start ## to inline the server create from the java process, we won't get ## the correct permissions if $os400lib && [ ! -d "${SERVER_CONFIG_DIR}" ] && [ "defaultServer" = "${SERVER_NAME}" ] then # Create the server or exit the script createServer || exit $? fi SAVE_JVM_OPTIONS_QUOTED=${JVM_OPTIONS_QUOTED} JVM_OPTIONS_QUOTED=${SERVER_JVM_OPTIONS_QUOTED} SAVE_IBM_JAVA_OPTIONS=${IBM_JAVA_OPTIONS} IBM_JAVA_OPTIONS=${SERVER_IBM_JAVA_OPTIONS} SAVE_OPENJ9_JAVA_OPTIONS=${OPENJ9_JAVA_OPTIONS} OPENJ9_JAVA_OPTIONS=${SERVER_IBM_JAVA_OPTIONS} if $os400lib; then serverCmdOS400 "${SERVER_CMD_BACKGROUND_LOG}" "${SERVER_NAME}" "$@" rc=$? JVM_OPTIONS_QUOTED=${SAVE_JVM_OPTIONS_QUOTED} IBM_JAVA_OPTIONS=${SAVE_IBM_JAVA_OPTIONS} OPENJ9_JAVA_OPTIONS=${SAVE_OPENJ9_JAVA_OPTIONS} if [ -n "${SERVER_CMD_BACKGROUND_LOG}" ]; then PID=`cat "${X_PID_FILE}"` # Verify/wait for the process to start javaCmd '' "${SERVER_NAME}" --pid="${PID}" --status:start "$@" rc=$? fi elif [ "${uname}" = OS/390 ] && [ -n "${WLP_ZOS_PROCEDURE}" ] && [ -e "${WLP_INSTALL_DIR}/lib/native/zos/s390x/bbgzcsl" ]; then # Start the STC procedure if [ -n "${WLP_ZOS_JOBNAME}" ]; then "${WLP_INSTALL_DIR}/lib/native/zos/s390x/bbgzcsl" "${WLP_ZOS_PROCEDURE}" "${SERVER_NAME}" "${X_PID_FILE}" "${WLP_ZOS_JOBNAME}" "$@" else "${WLP_INSTALL_DIR}/lib/native/zos/s390x/bbgzcsl" "${WLP_ZOS_PROCEDURE}" "${SERVER_NAME}" "${X_PID_FILE}" "$@" fi rc=$? JVM_OPTIONS_QUOTED=${SAVE_JVM_OPTIONS_QUOTED} IBM_JAVA_OPTIONS=${SAVE_IBM_JAVA_OPTIONS} OPENJ9_JAVA_OPTIONS=${SAVE_OPENJ9_JAVA_OPTIONS} if [ $rc = 0 ]; then # Verify/wait for the process to start PID=`cat "${X_PID_FILE}"` javaCmd '' "${SERVER_NAME}" --pid="${PID}" --status:start "$@" rc=$? elif [ $rc = 20 ]; then # PID file not created javaCmd '' --message:error.zosProcStart.create.pidfile "${SERVER_NAME}" "${WLP_ZOS_PROCEDURE}" rc=$? if [ $rc = 0 ]; then rc=22 fi elif [ $rc = 21 ]; then # Command has exceeded the max allowable length for MGCRE javaCmd '' --message:error.zosProcStart.start.length "${WLP_ZOS_PROCEDURE}" rc=$? if [ $rc = 0 ]; then rc=22 fi elif [ $rc = 22 ]; then # The specified z/OS procedure name is invalid javaCmd '' --message:error.zosProcStart.procedure.invalid "${WLP_ZOS_PROCEDURE}" rc=$? if [ $rc = 0 ]; then rc=22 fi elif [ $rc = 23 ]; then # The specified z/OS jobname is invalid javaCmd '' --message:error.zosProcStart.jobname.invalid "${WLP_ZOS_PROCEDURE}" "${WLP_ZOS_JOBNAME}" rc=$? if [ $rc = 0 ]; then rc=22 fi else # Problem issuing MGCRE javaCmd '' --message:error.zosProcStart.mvs.start "${WLP_ZOS_PROCEDURE}" "$rc" rc=$? if [ $rc = 0 ]; then rc=22 fi fi else X_CMD="${JAVA_CMD} ${ARGS}" export X_CMD javaCmd "${SERVER_CMD_BACKGROUND_LOG}" "${SERVER_NAME}" "$@" rc=$? PID=$! JVM_OPTIONS_QUOTED=${SAVE_JVM_OPTIONS_QUOTED} IBM_JAVA_OPTIONS=${SAVE_IBM_JAVA_OPTIONS} OPENJ9_JAVA_OPTIONS=${SAVE_OPENJ9_JAVA_OPTIONS} if [ -n "${SERVER_CMD_BACKGROUND_LOG}" ]; then # Verify/wait for the process to start javaCmd '' "${SERVER_NAME}" --pid="${PID}" --status:start "$@" rc=$? # write the pid file if return is OK or UNKNOWN if [ $rc = 0 -o $rc = $SERVER_UNKNOWN_STATUS ]; then safeEcho "${PID}" > "${X_PID_FILE}" fi fi fi return $rc } JAVA_DEBUG= JVM_OPTIONS_QUOTED= INVOKED="$0" export INVOKED case "$ACTION" in # Start the server in the foreground run | debug) if serverEnvAndJVMOptions then : else exit $? fi if checkServer true then if [ "${ACTION}" = "debug" ] then if [ -z "${WLP_DEBUG_ADDRESS}" ] then WLP_DEBUG_ADDRESS=7777 fi if [ -z "${WLP_DEBUG_SUSPEND}" ] then WLP_DEBUG_SUSPEND=y fi if [ "${WLP_DEBUG_REMOTE}" = "y" ] then WLP_DEBUG_REMOTE_HOST="0.0.0.0:" else WLP_DEBUG_REMOTE_HOST="" fi JAVA_DEBUG="-Dwas.debug.mode=true -Dsun.reflect.noInflation=true -agentlib:jdwp=transport=dt_socket,server=y,suspend=${WLP_DEBUG_SUSPEND},address=${WLP_DEBUG_REMOTE_HOST}${WLP_DEBUG_ADDRESS}" fi serverWorkingDirectory # WLP_JAR_CYGWIN is used only in support of java -jar startup of a Liberty server. # When WLP_JAR_CYGWIN=true (or synonym) is specied, the PID of the launching # process (i.e. parent of server process) is determined and stored in the PID file # for use by the java -jar shutdown hook to ensure termination of the launching # process. This is necessary because the launching process does not terminate on # its own under cygwin and if left behind holds file locks that prevent cleanup # of the java -jar extraction directory. if [ "$WLP_JAR_CYGWIN" = "true" -o "$WLP_JAR_CYGWIN" = "1" -o "$WLP_JAR_CYGWIN" = "TRUE" -o "$WLP_JAR_CYGWIN" = "True" ] then serverCmd '' "$@" & PID=$! mkdirs "${X_PID_DIR}" # find parent PID and store it SPID=`ps -ef | while read l; do grep $PID | awk -v PID=$PID '{ if ( $3 == PID ) print $2 }'; done` safeEcho "${SPID}" > "${X_PID_FILE}" wait "${PID}" # wait because this rc=$? else serverCmd '' "$@" rc=$? fi exit $rc else exit 2 fi ;; # Start the server in the background start) if serverEnvAndJVMOptions then : else exit $? fi if checkServer true then # We can't start the server in the background if it is already running. serverStatus false --status:starting rc=$? case $rc in "0" ) rc=1 ;; "1" ) serverWorkingDirectory mkdirs "${X_LOG_DIR}" if [ -f "${X_LOG_DIR}/${X_LOG_FILE}" ] && [ ! -w "${X_LOG_DIR}/${X_LOG_FILE}" ] then javaCmd '' --message:error.fileNotFound "${X_LOG_DIR}/${X_LOG_FILE}" rc=$? if [ $rc = 0 ]; then rc=22 fi exit $rc fi mkdirs "${X_PID_DIR}" rmIfExist "${X_PID_FILE}" mkdirs "${SERVER_OUTPUT_DIR}/workarea" touchIfNotExist "${SERVER_OUTPUT_DIR}/workarea/.sLock" rmIfExist "${SERVER_OUTPUT_DIR}/workarea/.sCommand" # Start the target server with the provided arguments serverCmd "${X_LOG_DIR}/${X_LOG_FILE}" "$@" rc=$? if [ $rc = 1 ]; then # The launcher failed (due to bad JVM arguments, for example). # Translate to a better error code. rc=22 fi ;; esac exit $rc else exit 2 fi ;; create) installEnv createServer "$@" exit $rc ;; # Stop the server. stop) serverEnv if checkServer true then PID= if [ -f "${X_PID_FILE}" ]; then PID=`cat "${X_PID_FILE}"` fi javaCmd '' "${SERVER_NAME}" --pid="${PID}" --stop "$@" rc=$? case "$rc" in "0" ) rm -f "${X_PID_FILE}" ;; "1" ) rmIfExist "${X_PID_FILE}" "${SERVER_OUTPUT_DIR}/workarea/.sCommand" ;; esac exit $rc else exit 2 fi ;; # Check if server is running status) serverEnv if checkServer true then serverPIDStatus mkdirs "${X_LOG_DIR}" javaCmd '' "${SERVER_NAME}" --pid="${PID}" --status rc=$? if [ $rc = 1 ]; then rmIfExist "${X_PID_FILE}" "${SERVER_OUTPUT_DIR}/workarea/.sCommand" fi exit $rc else exit 2 fi ;; status:fast) serverEnv if checkServer false then serverStatus true --status exit $? else exit 2 fi ;; # Package up the runtime and target server configuration package) if serverEnvAndJVMOptions then : else exit $? fi # Check to see if the server exists if checkServer true then serverPIDStatus JVM_OPTIONS_QUOTED=${SERVER_JVM_OPTIONS_QUOTED} javaCmd '' "${JVM_OPTIONS_QUOTED}" "${SERVER_NAME}" --pid="${PID}" --package "$@" exit $? else exit 2 fi ;; # dump the server's configs/logs/status to a zip file dump) serverEnv # Check to see if the server exists if checkServer true then javaCmd '' "${SERVER_NAME}" --dump "$@" exit $? else exit 2 fi ;; # dump JVM status javadump) serverEnv if checkServer true then javaCmd '' "${SERVER_NAME}" --javadump "$@" exit $? else exit 2 fi ;; # pause the server pause) serverEnv # Check to see if the server exists if checkServer true then javaCmd '' "${SERVER_NAME}" --pause "$@" exit $? else exit 2 fi ;; # resume the server resume) serverEnv # Check to see if the server exists if checkServer true then javaCmd '' "${SERVER_NAME}" --resume "$@" exit $? else exit 2 fi ;; version) installEnv javaCmd '' --version ;; list) installEnv javaCmd '' --list ;; help) installEnv javaCmd '' --help ${SERVER_NAME} ;; help:usage) installEnv javaCmd '' --help:usage ;; *) installEnv javaCmd '' --help:actions:${ACTION} ;; esac exit 0