FWD » Core Development » User Interface

#!/bin/bash

#set -x

# Default values

P2J_JAR="../lib/p2j.jar"

DIR_XML=""

APPCDS_DIR=""

show_usage()

{

   i=0;        usage[$i]="Usage: $(basename $0) [-f <directory.xml>] [-d <appcds_dir>] [path_to_p2j.jar]"

   i=$((i+1)); usage[$i]="Where:"

   i=$((i+1)); usage[$i]="path_to_p2j.jar \t= Path to p2j.jar (default=\"../lib/p2j.jar\")"

   i=$((i+1)); usage[$i]="-f | --file \t= Path to directory.xml (default=\"../server/directory.xml\")"

   i=$((i+1)); usage[$i]="-d | --dir \t= Path to output appcds folder (default=\"../appcds/client\")"

   i=$((i+1)); usage[$i]="-h | --help \t= Usage information"

   for i in "${usage[@]}"; do

      echo -e "$i"

   done

}

while [[ $# -gt 0 ]]; do

    case "$1" in

        -h|--help|-\?)

            show_usage

            exit 1

            ;;

        -f|--file)

            DIR_XML="$2"

            shift 2

            ;;

        -d|--dir)

            APPCDS_DIR="$2"

            shift 2

            ;;

        *)

            if [[ "$1" == -* ]]; then

                echo "Unknown option: $1"

                show_usage

                exit 1

            fi

            # Positional argument

            P2J_JAR="$1"

            shift

            ;;

    esac

done

# Resolve DEPLOY_HOME relative to this script

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

DEPLOY_HOME="$(cd "$SCRIPT_DIR/.." && pwd)"

# Ensure P2J_JAR is an absolute path if it exists

if [[ "$P2J_JAR" != /* ]]; then

    P2J_JAR="$PWD/$P2J_JAR"

fi

DIR_XML="${DIR_XML:-$DEPLOY_HOME/server/directory.xml}"

if [[ "$DIR_XML" != /* ]]; then

    DIR_XML="$PWD/$DIR_XML"

fi

APPCDS_DIR="${APPCDS_DIR:-$DEPLOY_HOME/appcds/client}"

if [[ "$APPCDS_DIR" != /* ]]; then

    APPCDS_DIR="$PWD/$APPCDS_DIR"

fi

if [ ! -f "$DIR_XML" ]; then

    echo "Error: $DIR_XML not found."

    exit 1

fi

TMP_PROPS=$(mktemp)

java -cp "$P2J_JAR" com.goldencode.util.JvmArgsExtractor -f "$DIR_XML" -o "$TMP_PROPS"

if [ $? -ne 0 ]; then

    echo "Error: Failed to extract JVM args."

    rm -f "$TMP_PROPS"

    exit 1

fi

# Read properties into dynamically named variables

while IFS='=' read -r key value; do

    if [[ $key == \#* ]] || [ -z "$key" ]; then

        continue

    fi

    key=$(echo "$key" | xargs)

    value="${value//\\:/:}"

    value="${value//\\=/=}"

    var_name="${key//./_}"

    var_name="${var_name//-/_}"

    declare "$var_name=$value"

done < "$TMP_PROPS"

rm -f "$TMP_PROPS"

# Remove existing appcds directory to prevent Java from reusing a stale .jsa archive.

# The JVM does not overwrite an existing SharedArchiveFile in-place; removing the

# directory guarantees a clean dump on every run.

if [ -d "$APPCDS_DIR" ]; then

    rm -rf "$APPCDS_DIR"

fi

mkdir -p "$APPCDS_DIR"

if [ -z "$appcds_clients" ]; then

    echo "No clients found for AppCDS."

    exit 0

fi

# Source the application name so getcp.sh can locate the application jar.

appname=""

[ -f "$DEPLOY_HOME/client/appname" ] && . "$DEPLOY_HOME/client/appname"

IFS=',' read -ra clients <<< "$appcds_clients"

for client_type in "${clients[@]}"; do

    client_type=$(echo "$client_type" | xargs)

    if [ -z "$client_type" ]; then

        continue

    fi

    echo "Processing client: $client_type"

    cp_var="appcds_classpath_$client_type"

    args_var="appcds_jvmargs_$client_type"

    client_args="${!args_var}"

    # JvmArgsExtractor only reports <libPath>/p2j.jar for the classpath. Build the

    # COMPLETE client runtime classpath the same way client.sh does -- via getcp.sh

    # run from the client dir -- and freeze it (below) to <type>.cpath. This makes

    # the classpath the archive is dumped against byte-for-byte identical to the one

    # the client replays (getcp.sh --appcds), so AppCDS's classpath check passes.

    # FWD_LIB points at the curated client deploy root (the parent of the lib dir

    # holding p2j.jar) so getcp.sh resolves the curated client library set.

    appcds_p2j="${!cp_var}"

    appcds_p2j="${appcds_p2j%%:*}"

    appcds_lib_dir="$(cd "$(dirname "$appcds_p2j")" 2>/dev/null && pwd)"

    appcds_fwd_root="$(dirname "$appcds_lib_dir")"

    client_cp="$(cd "$DEPLOY_HOME/client" && FWD_LIB="$appcds_fwd_root" "$DEPLOY_HOME/getcp.sh" "$appname" "$DEPLOY_HOME/client")"

    client_cp="${client_cp%:}"

    echo "JVM classpath for $client_type: $client_cp"

    echo "JVM args for $client_type: $client_args"

    base_lst=$(mktemp)

    runtime_lst=$(mktemp)

    # 1. LstExporter (run from the client dir so relative classpath entries resolve

    #    the same way they will at runtime)

    cd "$DEPLOY_HOME/client" || exit 1

    java -cp "$client_cp" com.goldencode.util.LstExporter \

        "com.goldencode.p2j.main.ClientDriver" \

        "com.goldencode.p2j.ui.client" \

        "-com.goldencode.p2j.persist" \

        "-com.goldencode.p2j.main.StandardServer" \

        "!com.goldencode.p2j.util" \

        "-o" "$base_lst"

    if [ $? -ne 0 ]; then

        echo "Error: LstExporter failed for $client_type"

        rm -f "$base_lst" "$runtime_lst"

        exit 1

    fi

    # 2. ClientDriver to dump runtime class list (also from the client dir)

    cd "$DEPLOY_HOME/client" || exit 1

    java -cp "$client_cp" \

        -Djava.library.path="$DEPLOY_HOME/lib" \

        -XX:DumpLoadedClassList="$runtime_lst" \

        com.goldencode.p2j.main.ClientDriver

    # 3. Concatenate. Add markers

    final_lst="$APPCDS_DIR/${client_type}.lst"

    sed -i '1i# This is base_lst' $base_lst

    sed -i '1i# This is runtime_lst' $runtime_lst

    cat "$base_lst" "$runtime_lst" > "$final_lst"

    # LstExporter copies SPI provider entries from META-INF/services/* verbatim, and

    # those files may carry inline comments that are legal per the ServiceLoader spec

    # (e.g. ecj's javax.tools.JavaCompiler lists

    #   org.eclipse.jdt...EclipseCompiler #Eclipse compiler).

    # The -Xshare:dump class-list parser rejects a class name followed by such a

    # trailing comment, so strip any inline "#..." while leaving full-line comments

    # (lines that begin with #) intact.

    sed -i 's/\([^[:space:]]\)[[:space:]]*#.*$/\1/' "$final_lst"

    # 4. Build JSA archive

    cd "$DEPLOY_HOME/client" || exit 1

    # We must split client_args on spaces properly without quotes

    # so that -Xmx512m -Dfoo=bar are treated as separate args

    java -cp "$client_cp" \

        -Djava.library.path="$DEPLOY_HOME/lib" \

        -Xshare:dump \

        -XX:SharedClassListFile="$APPCDS_DIR/${client_type}.lst" \

        -XX:SharedArchiveFile="$APPCDS_DIR/${client_type}.jsa" \

        $client_args \

        com.goldencode.p2j.main.ClientDriver

    if [ $? -ne 0 ]; then

        echo "Error: JSA archive generation failed for $client_type"

        rm -f "$base_lst" "$runtime_lst"

        exit 1

    fi

    # Record the exact classpath the archive was dumped against, alongside the

    # .jsa/.lst. The client runtime (getcp.sh --appcds) reads this file so its

    # classpath matches the archive. AppCDS requires the dumped classpath to be

    # a prefix of the runtime classpath, so these must stay in lock-step. The

    # client never has access to directory.xml, which is why this is published

    # here at prepare time instead.

    echo "$client_cp" > "$APPCDS_DIR/${client_type}.cpath"

    #rm -f "$base_lst" "$runtime_lst"

done

echo "AppCDS deployment completed successfully."