FWD » Core Development » User Interface

#!/bin/bash

# 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

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_cp="${!cp_var}"

    client_args="${!args_var}"

    # Directory holding p2j.jar (and its manifest-referenced jars). Used only when

    # INCLUDE_STATIC=true, to give LstExporter an explicit classpath to analyze --

    # the manifest expansion is not visible via java.class.path.

    appcds_lib_dir="$(cd "$(dirname "${client_cp%%:*}")" 2>/dev/null && pwd)"

    echo "JVM classpath for $client_type: $client_cp"

    echo "JVM args for $client_type: $client_args"

    base_lst=$(mktemp)

    runtime_lst=$(mktemp)

    # 1. (Optional) LstExporter static reachability. OFF by default: walking the whole

    #    classpath yields ~18k classes / ~140MB .jsa, while a real client loads ~2k --

    #    the bloat balloons per-client memory with no benefit. Enable INCLUDE_STATIC=true

    #    for broader coverage. It needs an EXPLICIT classpath (the lib dir's jars),

    #    because under -cp p2j.jar the manifest-referenced jars are invisible to it.

    if [ "${INCLUDE_STATIC:-false}" = "true" ]; then

        static_cp="$client_cp"

        for j in "$appcds_lib_dir"/*.jar; do

            [ "$j" = "${client_cp%%:*}" ] || static_cp="$static_cp:$j"

        done

        cd "$DEPLOY_HOME/client" || exit 1

        java -cp "$static_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

    fi

    # 2. ClientDriver to dump the runtime (actually-loaded) class list.

    cd /tmp || exit 1

    java -cp "$client_cp" \

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

        -XX:DumpLoadedClassList="$runtime_lst" \

        com.goldencode.p2j.main.ClientDriver

    # 3. Assemble the class list. Default = runtime-loaded set only (lean archive that

    #    matches what the client actually uses). Prepend the static set only when

    #    INCLUDE_STATIC produced one.

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

    if [ -s "$base_lst" ]; then

        sed -i '1i# base_lst (static)' "$base_lst"

        sed -i '1i# runtime_lst' "$runtime_lst"

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

    else

        cp "$runtime_lst" "$final_lst"

    fi

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