forked from openkylin/java-wrappers
321 lines
8.8 KiB
Bash
321 lines
8.8 KiB
Bash
# wrappers.sh: various functions to be used by Java script wrappers
|
|
# Copyright 2008 by Vincent Fourmond <fourmond@debian.org>
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public
|
|
# License as published by the Free Software Foundation; either
|
|
# version 2.1 of the License, or (at your option) any later version.
|
|
|
|
# This library is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# Lesser General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
# Import the list of JVMs
|
|
|
|
. /usr/lib/java-wrappers/jvm-list.sh
|
|
|
|
# Display a debugging message
|
|
java_debug() {
|
|
if [ "$DEBUG_WRAPPER" ]; then
|
|
echo "[debug] $0: $@" >&2;
|
|
fi
|
|
}
|
|
|
|
# Displays a warning
|
|
java_warning() {
|
|
echo "[warning] $0: $@" >&2;
|
|
}
|
|
|
|
# Exit with an error message
|
|
java_fail() {
|
|
echo "[error] $0: $@" >&2;
|
|
exit 1;
|
|
}
|
|
|
|
# Try to get the amount of memory available on the machine to come up
|
|
# with a decent -Xmx argument, returned as the value of the
|
|
# determined_xmx_arg (defaults in kilobytes, so you should add k
|
|
# afterwards)
|
|
determine_xmx_arg() {
|
|
# Yes, that's ugly, so what ??
|
|
mem=`free -k 2>/dev/null | head -n2 | tail -n1 | sed -r s/'[^0-9]+//' | cut -d' ' -f1`
|
|
|
|
}
|
|
|
|
# Try to find a Java runtime and set JAVA_HOME and JAVA_CMD accordingly.
|
|
# If JAVA_CMD exists, nothing is done. If JAVA_HOME exists, only that
|
|
# is searched.
|
|
#
|
|
# The full list of JVM names understood can be found in the file
|
|
# /usr/lib/java-wrappers/jvm-list.sh.
|
|
#
|
|
# More than one argument can be specified; they will be taken into account
|
|
# in that order; the first one found will be selected.
|
|
#
|
|
# If JAVA_DEBUGGER is set, we try to use jdb rather than java, if it is
|
|
# present.
|
|
#
|
|
# This information is currently *far from complete* !!!
|
|
find_java_runtime() {
|
|
|
|
if [ "$JAVA_CMD" ]; then
|
|
if which "$JAVA_CMD" > /dev/null; then
|
|
java_debug "Using already set JAVA_CMD = '$JAVA_CMD' => '"`which "$JAVA_CMD"`"'"
|
|
return 0; # Nothing to do
|
|
else
|
|
java_warning "JAVA_CMD was set to '$JAVA_CMD', but which(1) does not find it."
|
|
java_warning "Therefore ignoring JAVA_CMD"
|
|
fi
|
|
fi
|
|
|
|
if [ "$JAVA_BINDIR" ]; then
|
|
if [ "$JAVA_DEBUGGER" ] && [ -x "$JAVA_BINDIR/jdb" ]; then
|
|
JAVA_CMD="$JAVA_BINDIR/jdb"
|
|
elif [ -x "$JAVA_BINDIR/java" ]; then
|
|
JAVA_CMD="$JAVA_BINDIR/java"
|
|
fi
|
|
if [ "$JAVA_CMD" ]; then
|
|
java_debug "Using '$JAVA_CMD' from JAVA_BINDIR = '$JAVA_BINDIR'"
|
|
return 0;
|
|
else
|
|
java_warning "JAVA_BINDIR = '$JAVA_BINDIR' does not point to a java binary"
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$JAVA_HOME" ]; then
|
|
|
|
# We now try to look for a reasonable JAVA_HOME.
|
|
# First, narrow the choices according to what
|
|
# was asked.
|
|
#
|
|
# Please see the list of understood jvms in
|
|
# /usr/lib/java-wrappers/jvm-list.sh
|
|
|
|
DIRS=""
|
|
|
|
# If no arguments are given, we take it as 'all'
|
|
if test -z "$1"; then
|
|
set all
|
|
fi
|
|
|
|
while test "$1"
|
|
do
|
|
if echo $1 | egrep -- '[^0-9A-Za-z_]'; then
|
|
java_warning "JVM flavor '${1}' contains illegal characters"
|
|
else
|
|
found_jvm=$(eval "echo -n \$__jvm_$1")
|
|
if [ -z "$found_jvm" ] ; then
|
|
java_warning "JVM flavor '${1:-none}' not understood"
|
|
else
|
|
DIRS="$DIRS $found_jvm"
|
|
fi
|
|
fi
|
|
shift
|
|
done
|
|
# Nothing means everything
|
|
if [ -z "$DIRS" ]; then
|
|
DIRS=$all_runtimes
|
|
fi
|
|
# First, we check if __jvm_alt is within the possible choices:
|
|
if echo "$DIRS" | fgrep "$__jvm_alt" > /dev/null ; then
|
|
JAVA_HOME="$__jvm_alt"
|
|
java_debug "Picking up the JVM designated by the alternatives system: "
|
|
java_debug " JAVA_HOME = '$JAVA_HOME'"
|
|
else
|
|
|
|
# And pick up the first one that works reasonably
|
|
for dir in $DIRS; do
|
|
if [ -x $dir/bin/java ]; then
|
|
JAVA_HOME=$dir
|
|
break;
|
|
fi
|
|
done
|
|
fi
|
|
else
|
|
java_debug "Using provided JAVA_HOME = '$JAVA_HOME'"
|
|
fi
|
|
if [ "$JAVA_HOME" ] ; then
|
|
if [ "$JAVA_DEBUGGER" ] && [ -x "$JAVA_HOME/bin/jdb" ]; then
|
|
JAVA_CMD="$JAVA_HOME/bin/jdb"
|
|
else
|
|
JAVA_CMD="$JAVA_HOME/bin/java"
|
|
fi
|
|
java_debug "Found JAVA_HOME = '$JAVA_HOME'"
|
|
java_debug "Found JAVA_CMD = '$JAVA_CMD'"
|
|
return 0 # Fine
|
|
else
|
|
java_warning "No java runtime was found"
|
|
return 1;
|
|
fi
|
|
}
|
|
|
|
|
|
# Some initializations:
|
|
if [ "$JAVA_CLASSPATH" ]; then
|
|
java_debug "Building classpath on JAVA_CLASSPATH = '$JAVA_CLASSPATH'"
|
|
else
|
|
JAVA_CLASSPATH=
|
|
fi
|
|
|
|
|
|
if [ "$JAVA_JARPATH" ]; then
|
|
java_debug "Jar lookup is done in JAVA_JARPATH = '$JAVA_JARPATH'"
|
|
else
|
|
JAVA_JARPATH=/usr/share/java
|
|
fi
|
|
|
|
|
|
# If the user provides a JAVA_FLAVOR environment variable, we
|
|
# force the runtime to be the given flavor, such as for find_java_runtime
|
|
if [ "$JAVA_FLAVOR" ]; then
|
|
find_java_runtime "$JAVA_FLAVOR" || \
|
|
java_warning "Could not find runtime for user-supplied flavor '${JAVA_FLAVOR}"
|
|
fi
|
|
|
|
|
|
# Same as find_java_runtime, but fails with an error if
|
|
# nothing is found.
|
|
require_java_runtime() {
|
|
find_java_runtime "$@" || \
|
|
java_fail "Unable to find an appropriate java runtime. See java_wrappers(7) for help"
|
|
}
|
|
|
|
# Looks for a jar file and returns its location as the
|
|
# found_jar variable, or fails if no jar was found.
|
|
locate_jar() {
|
|
jar="$1"
|
|
if [ -r $JAVA_JARPATH/$jar ]; then
|
|
found_jar=$JAVA_JARPATH/$jar
|
|
elif [ -r $JAVA_JARPATH/$jar.jar ]; then
|
|
found_jar=$JAVA_JARPATH/$jar.jar
|
|
elif [ -r $jar ]; then
|
|
found_jar=$jar
|
|
elif [ -r $jar.jar ]; then
|
|
found_jar=$jar.jar
|
|
else
|
|
return 1 # Not found
|
|
fi
|
|
return 0 # Found
|
|
}
|
|
|
|
# Find jars and add them to the classpath
|
|
find_jars() {
|
|
looked_for_jars=1
|
|
for jar in $@ ; do
|
|
if locate_jar $jar; then
|
|
if [ -z "$JAVA_CLASSPATH" ]; then
|
|
JAVA_CLASSPATH=$found_jar
|
|
else
|
|
JAVA_CLASSPATH=$JAVA_CLASSPATH:$found_jar
|
|
fi
|
|
else
|
|
java_warning "Unable to locate $jar in $JAVA_JARPATH"
|
|
fi
|
|
done
|
|
}
|
|
|
|
# Recursively adds the jar and its classpath to the classpath
|
|
_recurse_jar_classpath() {
|
|
if [ -r "$1" ]; then
|
|
if echo $JAVA_CLASSPATH | fgrep "$1" > /dev/null; then
|
|
return 0;
|
|
fi
|
|
JAVA_CLASSPATH=$JAVA_CLASSPATH:$1
|
|
java_debug "Looking at classpath of jar: '$1'"
|
|
for jar in $(/usr/lib/java-wrappers/get-classpath "$1"); do
|
|
if [ "${jar##/}" = "$jar" ]; then
|
|
# Relative path = path relative to the location of the
|
|
# JAR file !
|
|
jar=$(dirname $1)/$jar
|
|
fi
|
|
_recurse_jar_classpath $jar;
|
|
done
|
|
else
|
|
java_debug "Unable to find file $1 that may be needed"
|
|
return 1;
|
|
fi
|
|
}
|
|
|
|
# This function tries to mimick the behaviour of the -jar option of
|
|
# the java executable, by adding the target jar and all its classpath
|
|
# recursively.
|
|
#
|
|
# This function is experimental for now, and its interface is not very
|
|
# well specified yet.
|
|
#
|
|
# It will return without problem if the target class already is in the
|
|
# classpath. It aborts with an error if a JAR file can't be found.
|
|
find_jar_classpath() {
|
|
if locate_jar "$1"; then
|
|
looked_for_jars=1
|
|
_recurse_jar_classpath $found_jar
|
|
else
|
|
java_warn "Unable to find the jar file $jar"
|
|
return 1;
|
|
fi
|
|
}
|
|
|
|
|
|
|
|
# Adds the first jar found to the classpath. Useful for alternative
|
|
# dependencies.
|
|
find_one_jar_in() {
|
|
looked_for_jars=1
|
|
for jar in $@ ; do
|
|
if locate_jar $jar; then
|
|
JAVA_CLASSPATH=$JAVA_CLASSPATH:$found_jar
|
|
return 0
|
|
fi
|
|
done
|
|
java_warning "Could fine none of $@ in $JAVA_JARPATH"
|
|
return 1
|
|
}
|
|
|
|
# Runs the program !
|
|
run_java() {
|
|
if [ -z "$JAVA_CMD" ]; then
|
|
java_warning "No JAVA_CMD set for run_java, falling back to JAVA_CMD = java"
|
|
JAVA_CMD=java
|
|
fi
|
|
# We try to conjure up a JAVA_HOME from JAVA_CMD, if the former
|
|
# is absent. Idea coming from bug #404728.
|
|
if [ -z "$JAVA_HOME" ]; then
|
|
full_cmd_path="$(readlink -f `which $JAVA_CMD`)"
|
|
JAVA_HOME="${full_cmd_path%bin/*}"
|
|
java_debug "Using JAVA_CMD to find JAVA_HOME = '$JAVA_HOME'"
|
|
fi
|
|
if [ "$FORCE_CLASSPATH" ]; then
|
|
java_debug "Using imposed classpath : FORCE_CLASSPATH = '$FORCE_CLASSPATH'";
|
|
cp="-classpath $FORCE_CLASSPATH";
|
|
elif [ "$JAVA_CLASSPATH" ]; then
|
|
cp="-classpath $JAVA_CLASSPATH";
|
|
else
|
|
cp="";
|
|
fi
|
|
# Exporting JAVA_HOME, I guess it can't hurt much, can it ?
|
|
export JAVA_HOME
|
|
java_debug "Environment variable CLASSPATH is '$CLASSPATH'"
|
|
java_debug "Runnning $JAVA_CMD $JAVA_ARGS $cp $@"
|
|
exec $JAVA_CMD $JAVA_ARGS $cp "$@"
|
|
}
|
|
|
|
# Runs a java jar.
|
|
# You don't have to use this function to run a jar, but you might find
|
|
# it useful, though.
|
|
run_jar() {
|
|
if [ "$looked_for_jars" ]; then
|
|
java_warning "It is most likely useless to use find_jar when running"
|
|
java_warning "a class with run_jar (-classpath is ignored)"
|
|
fi
|
|
if locate_jar $1; then
|
|
shift
|
|
run_java -jar "$found_jar" "$@"
|
|
else
|
|
java_fail "Unable to find jar $1 in $JAVA_JARPATH"
|
|
fi
|
|
} |