/[gentoo-x86]/eclass/java-utils-2.eclass
Gentoo

Diff of /eclass/java-utils-2.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.75 Revision 1.107
4# Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org> 4# Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org>
5# Copyright (c) 2004-2005, Gentoo Foundation 5# Copyright (c) 2004-2005, Gentoo Foundation
6# 6#
7# Licensed under the GNU General Public License, v2 7# Licensed under the GNU General Public License, v2
8# 8#
9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.75 2007/04/20 16:13:46 betelgeuse Exp $ 9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.107 2008/05/03 21:28:45 betelgeuse Exp $
10
11 10
12# ----------------------------------------------------------------------------- 11# -----------------------------------------------------------------------------
13# @eclass-begin 12# @eclass-begin
14# @eclass-shortdesc Java Utility eclass 13# @eclass-shortdesc Java Utility eclass
15# @eclass-maintainer java@gentoo.org 14# @eclass-maintainer java@gentoo.org
58#WANT_ANT_TASKS 57#WANT_ANT_TASKS
59 58
60# ----------------------------------------------------------------------------- 59# -----------------------------------------------------------------------------
61# @variable-internal JAVA_PKG_PORTAGE_DEP 60# @variable-internal JAVA_PKG_PORTAGE_DEP
62# 61#
63# The version of portage we need to function properly. At this moment it's 62# The version of portage we need to function properly. Previously it was
64# portage with phase hooks support. 63# portage with phase hooks support but now we use a version with proper env
64# saving.
65# ----------------------------------------------------------------------------- 65# -----------------------------------------------------------------------------
66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1_pre1" 66JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
67 67
68# ----------------------------------------------------------------------------- 68# -----------------------------------------------------------------------------
69# @variable-internal JAVA_PKG_E_DEPEND 69# @variable-internal JAVA_PKG_E_DEPEND
70# 70#
71# This is a convience variable to be used from the other java eclasses. This is 71# This is a convience variable to be used from the other java eclasses. This is
72# the version of java-config we want to use. We also need a recent version 72# the version of java-config we want to use. Usually the latest stable version
73# portage, that includes phase hooks. 73# so that ebuilds can use new features without depending on specific versions.
74# ----------------------------------------------------------------------------- 74# -----------------------------------------------------------------------------
75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.31 ${JAVA_PKG_PORTAGE_DEP}" 75JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.0.33-r1 ${JAVA_PKG_PORTAGE_DEP}"
76hasq source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
76 77
77# ----------------------------------------------------------------------------- 78# -----------------------------------------------------------------------------
78# @variable-external JAVA_PKG_ALLOW_VM_CHANGE 79# @variable-external JAVA_PKG_ALLOW_VM_CHANGE
79# @variable-default yes 80# @variable-default yes
80# 81#
195# 196#
196# @example 197# @example
197# java-pkg_doexamples demo 198# java-pkg_doexamples demo
198# java-pkg_doexamples demo/* examples/* 199# java-pkg_doexamples demo/* examples/*
199# 200#
201# @param --subdir - If the examples need a certain directory structure
200# @param $* - list of files to install 202# @param $* - list of files to install
201# ------------------------------------------------------------------------------ 203# ------------------------------------------------------------------------------
202java-pkg_doexamples() { 204java-pkg_doexamples() {
203 debug-print-function ${FUNCNAME} $* 205 debug-print-function ${FUNCNAME} $*
204 206
205 [[ ${#} -lt 1 ]] && die "At least one argument needed" 207 [[ ${#} -lt 1 ]] && die "At least one argument needed"
206 208
207 java-pkg_check-phase install 209 java-pkg_check-phase install
208 210
209 local dest=/usr/share/doc/${PF}/examples 211 local dest=/usr/share/doc/${PF}/examples
212 if [[ ${1} == --subdir ]]; then
213 local dest=${dest}/${2}
214 dodir ${dest}
215 shift 2
216 fi
217
210 if [[ ${#} = 1 && -d ${1} ]]; then 218 if [[ ${#} = 1 && -d ${1} ]]; then
211 ( # dont want to pollute calling env 219 ( # dont want to pollute calling env
212 insinto "${dest}" 220 insinto "${dest}"
213 doins -r ${1}/* 221 doins -r ${1}/*
214 ) || die "Installing examples failed" 222 ) || die "Installing examples failed"
282 fi 290 fi
283 done 291 done
284 292
285 java-pkg_do_write_ 293 java-pkg_do_write_
286} 294}
287
288 295
289# ------------------------------------------------------------------------------ 296# ------------------------------------------------------------------------------
290# @internal-function depend-java-query 297# @internal-function depend-java-query
291# 298#
292# Wrapper for the depend-java-query binary to enable passing USE in env. 299# Wrapper for the depend-java-query binary to enable passing USE in env.
549# ------------------------------------------------------------------------------ 556# ------------------------------------------------------------------------------
550# @ebuild-function java-pkg_dojavadoc 557# @ebuild-function java-pkg_dojavadoc
551# 558#
552# Installs javadoc documentation. This should be controlled by the doc use flag. 559# Installs javadoc documentation. This should be controlled by the doc use flag.
553# 560#
561# @param $1: optional --symlink creates to symlink like this for html
562# documentation bundles.
554# @param $1: - The javadoc root directory. 563# @param $2: - The javadoc root directory.
555# 564#
556# @example: 565# @example:
557# java-pkg_dojavadoc docs/api 566# java-pkg_dojavadoc docs/api
567# java-pkg_dojavadoc --symlink apidocs docs/api
558# 568#
559# ------------------------------------------------------------------------------ 569# ------------------------------------------------------------------------------
560java-pkg_dojavadoc() { 570java-pkg_dojavadoc() {
561 debug-print-function ${FUNCNAME} $* 571 debug-print-function ${FUNCNAME} $*
572
573 # For html documentation bundles that link to Javadoc
574 local symlink
575 if [[ ${1} = --symlink ]]; then
576 symlink=${2}
577 shift 2
578 fi
579
562 local dir="$1" 580 local dir="$1"
581 local dest=/usr/share/doc/${PF}/html
563 582
564 # QA checks 583 # QA checks
565 584
566 java-pkg_check-phase install 585 java-pkg_check-phase install
567 586
571 local msg="No index.html in javadoc directory" 590 local msg="No index.html in javadoc directory"
572 ewarn "${msg}" 591 ewarn "${msg}"
573 is-java-strict && die "${msg}" 592 is-java-strict && die "${msg}"
574 fi 593 fi
575 594
595 if [[ -e ${D}/${dest}/api ]]; then
596 eerror "${dest} already exists. Will not overwrite."
597 die "${dest}"
598 fi
599
576 # Renaming to match our directory layout 600 # Renaming to match our directory layout
577 601
578 local dir_to_install="${dir}" 602 local dir_to_install="${dir}"
579 if [[ "$(basename "${dir}")" != "api" ]]; then 603 if [[ "$(basename "${dir}")" != "api" ]]; then
580 dir_to_install="${T}/api" 604 dir_to_install="${T}/api"
582 cp -r "${dir}" "${dir_to_install}" || die "cp failed" 606 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
583 fi 607 fi
584 608
585 # Actual installation 609 # Actual installation
586 610
587 java-pkg_dohtml -r ${dir_to_install} 611 java-pkg_dohtml -r "${dir_to_install}"
612
613 # Let's make a symlink to the directory we have everything else under
614 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
615
616 if [[ ${symlink} ]]; then
617 debug-print "symlinking ${dest}/{api,${symlink}}"
618 dosym ${dest}/{api,${symlink}} || die
619 fi
588} 620}
589 621
590# ------------------------------------------------------------------------------ 622# ------------------------------------------------------------------------------
591# @ebuild-function java-pkg_dosrc 623# @ebuild-function java-pkg_dosrc
592# 624#
615 647
616 [[ ${#} -lt 1 ]] && die "At least one argument needed" 648 [[ ${#} -lt 1 ]] && die "At least one argument needed"
617 649
618 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then 650 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then
619 local msg="${FUNCNAME} called without app-arch/zip in DEPEND" 651 local msg="${FUNCNAME} called without app-arch/zip in DEPEND"
620 if is-java-strict; then 652 java-pkg_announce-qa-violation ${msg}
621 eerror "${msg}"
622 die "${msg}"
623 else
624 echo "${msg}"
625 echo "Please report this to http://bugs.gentoo.org."
626 fi
627 fi 653 fi
628 654
629 java-pkg_init_paths_ 655 java-pkg_init_paths_
630 656
631 local zip_name="${PN}-src.zip" 657 local zip_name="${PN}-src.zip"
831# @param $opt 857# @param $opt
832# --build-only - makes the jar(s) not added into package.env DEPEND line. 858# --build-only - makes the jar(s) not added into package.env DEPEND line.
833# (assumed automatically when called inside src_test) 859# (assumed automatically when called inside src_test)
834# --with-dependencies - get jars also from requested package's dependencies 860# --with-dependencies - get jars also from requested package's dependencies
835# transitively. 861# transitively.
862# --virtual - Packages passed to this function are to be handled as virtuals
863# and will not have individual jar dependencies recorded.
836# --into $dir - symlink jar(s) into $dir (must exist) instead of . 864# --into $dir - symlink jar(s) into $dir (must exist) instead of .
837# @param $1 - Package to get jars from. 865# @param $1 - Package to get jars from, or comma-separated list of packages in
866# case other parameters are not used.
838# @param $2 - jar from package. If not specified, all jars will be used. 867# @param $2 - jar from package. If not specified, all jars will be used.
839# @param $3 - When a single jar is specified, destination filename of the 868# @param $3 - When a single jar is specified, destination filename of the
840# symlink. Defaults to the name of the jar. 869# symlink. Defaults to the name of the jar.
841# ------------------------------------------------------------------------------ 870# ------------------------------------------------------------------------------
842# TODO could probably be cleaned up a little 871# TODO could probably be cleaned up a little
844 debug-print-function ${FUNCNAME} $* 873 debug-print-function ${FUNCNAME} $*
845 874
846 local build_only="" 875 local build_only=""
847 local destdir="." 876 local destdir="."
848 local deep="" 877 local deep=""
878 local virtual=""
849 879
850 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 880 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
851 881
852 while [[ "${1}" == --* ]]; do 882 while [[ "${1}" == --* ]]; do
853 if [[ "${1}" = "--build-only" ]]; then 883 if [[ "${1}" = "--build-only" ]]; then
854 build_only="true" 884 build_only="build"
855 elif [[ "${1}" = "--with-dependencies" ]]; then 885 elif [[ "${1}" = "--with-dependencies" ]]; then
856 deep="--with-dependencies" 886 deep="--with-dependencies"
887 elif [[ "${1}" = "--virtual" ]]; then
888 virtual="true"
857 elif [[ "${1}" = "--into" ]]; then 889 elif [[ "${1}" = "--into" ]]; then
858 destdir="${2}" 890 destdir="${2}"
859 shift 891 shift
860 else 892 else
861 die "java-pkg_jar-from called with unknown parameter: ${1}" 893 die "java-pkg_jar-from called with unknown parameter: ${1}"
865 897
866 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 898 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
867 899
868 [[ -z ${target_pkg} ]] && die "Must specify a package" 900 [[ -z ${target_pkg} ]] && die "Must specify a package"
869 901
902 if [[ "${EAPI}" == "1" ]]; then
903 target_pkg="${target_pkg//:/-}"
904 fi
905
870 # default destjar to the target jar 906 # default destjar to the target jar
871 [[ -z "${destjar}" ]] && destjar="${target_jar}" 907 [[ -z "${destjar}" ]] && destjar="${target_jar}"
872 908
873 local error_msg="There was a problem getting the classpath for ${target_pkg}." 909 local error_msg="There was a problem getting the classpath for ${target_pkg}."
874 local classpath 910 local classpath
875 classpath="$(java-config ${deep} --classpath=${target_pkg})" 911 classpath="$(java-config ${deep} --classpath=${target_pkg})"
876 [[ $? != 0 ]] && die ${error_msg} 912 [[ $? != 0 ]] && die ${error_msg}
877 913
914 # When we have commas this functions is called to bring jars from multiple
915 # packages. This affects recording of dependencencies performed later
916 # which expects one package only, so we do it here.
917 if [[ ${target_pkg} = *,* ]]; then
918 for pkg in ${target_pkg//,/ }; do
919 java-pkg_ensure-dep "${build_only}" "${pkg}"
920 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
921 done
922 # setting this disables further record-jar_ calls later
923 build_only="build"
924 else
878 java-pkg_ensure-dep "${build_only}" "${target_pkg}" 925 java-pkg_ensure-dep "${build_only}" "${target_pkg}"
926 fi
927
928 # Record the entire virtual as a dependency so that
929 # no jars are missed.
930 if [[ -z "${build_only}" && -n "${virtual}" ]]; then
931 java-pkg_record-jar_ "${target_pkg}"
932 # setting this disables further record-jars_ calls later
933 build_only="build"
934 fi
879 935
880 pushd ${destdir} > /dev/null \ 936 pushd ${destdir} > /dev/null \
881 || die "failed to change directory to ${destdir}" 937 || die "failed to change directory to ${destdir}"
882
883 # When we have commas this functions is called to bring jars from multiple
884 # packages. This affects recording of dependencencies because that syntax uses :
885 # if we don't change them to : gjl and java-config -d -p break
886 if [[ ${target_pkg} = *,* ]]; then
887 build_only="true"
888 java-pkg_record-jar_ ${target_pkg//,/:}
889 fi
890 938
891 local jar 939 local jar
892 for jar in ${classpath//:/ }; do 940 for jar in ${classpath//:/ }; do
893 local jar_name=$(basename "${jar}") 941 local jar_name=$(basename "${jar}")
894 if [[ ! -f "${jar}" ]] ; then 942 if [[ ! -f "${jar}" ]] ; then
957 debug-print-function ${FUNCNAME} $* 1005 debug-print-function ${FUNCNAME} $*
958 1006
959 local build_only="" 1007 local build_only=""
960 local deep="" 1008 local deep=""
961 1009
962 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1010 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
963 1011
964 while [[ "${1}" == --* ]]; do 1012 while [[ "${1}" == --* ]]; do
965 if [[ "${1}" = "--build-only" ]]; then 1013 if [[ "${1}" = "--build-only" ]]; then
966 build_only="true" 1014 build_only="build"
967 elif [[ "${1}" = "--with-dependencies" ]]; then 1015 elif [[ "${1}" = "--with-dependencies" ]]; then
968 deep="--with-dependencies" 1016 deep="--with-dependencies"
969 else 1017 else
970 die "java-pkg_jar-from called with unknown parameter: ${1}" 1018 die "java-pkg_jar-from called with unknown parameter: ${1}"
971 fi 1019 fi
973 done 1021 done
974 1022
975 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*" 1023 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
976 1024
977 1025
978 local classpath pkgs="${1}" 1026 local pkgs="${1}"
1027
1028 if [[ "${EAPI}" == "1" ]]; then
1029 pkgs="${pkgs//:/-}"
1030 fi
1031
979 jars="$(java-config ${deep} --classpath=${pkgs})" 1032 jars="$(java-config ${deep} --classpath=${pkgs})"
980 [[ $? != 0 || -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed" 1033 [[ $? != 0 ]] && die "java-config --classpath=${pkgs} failed"
981 debug-print "${pkgs}:${jars}" 1034 debug-print "${pkgs}:${jars}"
982 1035
983 for pkg in ${pkgs//,/ }; do 1036 for pkg in ${pkgs//,/ }; do
984 java-pkg_ensure-dep "${build_only}" "${pkg}" 1037 java-pkg_ensure-dep "${build_only}" "${pkg}"
985 done 1038 done
986 1039
987 if [[ -z "${classpath}" ]]; then
988 classpath="${jars}"
989 else
990 classpath="${classpath}:${jars}"
991 fi
992
993 # Only record jars that aren't build-only 1040 # Only record jars that aren't build-only
994 if [[ -z "${build_only}" ]]; then 1041 if [[ -z "${build_only}" ]]; then
995 oldifs="${IFS}"
996 IFS=","
997 for pkg in ${pkgs}; do 1042 for pkg in ${pkgs//,/ }; do
998 java-pkg_record-jar_ "${pkg}" 1043 java-pkg_record-jar_ "${pkg}"
999 done 1044 done
1000 IFS="${oldifs}"
1001 fi 1045 fi
1002 1046
1003 echo "${classpath}" 1047 echo "${jars}"
1004} 1048}
1005 1049
1006# ------------------------------------------------------------------------------ 1050# ------------------------------------------------------------------------------
1007# @ebuild-function java-pkg_getjar 1051# @ebuild-function java-pkg_getjar
1008# 1052#
1017# @example-return 1061# @example-return
1018# /usr/share/xerces-2/lib/xml-apis.jar 1062# /usr/share/xerces-2/lib/xml-apis.jar
1019# 1063#
1020# @param $opt 1064# @param $opt
1021# --build-only - makes the jar not added into package.env DEPEND line. 1065# --build-only - makes the jar not added into package.env DEPEND line.
1066# --virtual - Packages passed to this function are to be handled as virtuals
1067# and will not have individual jar dependencies recorded.
1022# @param $1 - package to use 1068# @param $1 - package to use
1023# @param $2 - jar to get 1069# @param $2 - jar to get
1024# ------------------------------------------------------------------------------ 1070# ------------------------------------------------------------------------------
1025java-pkg_getjar() { 1071java-pkg_getjar() {
1026 debug-print-function ${FUNCNAME} $* 1072 debug-print-function ${FUNCNAME} $*
1027 1073
1028 local build_only="" 1074 local build_only=""
1075 local virtual=""
1029 1076
1030 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1077 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1031 1078
1032 while [[ "${1}" == --* ]]; do 1079 while [[ "${1}" == --* ]]; do
1033 if [[ "${1}" = "--build-only" ]]; then 1080 if [[ "${1}" = "--build-only" ]]; then
1034 build_only="true" 1081 build_only="build"
1082 elif [[ "${1}" == "--virtual" ]]; then
1083 virtual="true"
1035 else 1084 else
1036 die "java-pkg_jar-from called with unknown parameter: ${1}" 1085 die "java-pkg_getjar called with unknown parameter: ${1}"
1037 fi 1086 fi
1038 shift 1087 shift
1039 done 1088 done
1040 1089
1041 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*" 1090 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
1042 1091
1043 local pkg="${1}" target_jar="${2}" jar 1092 local pkg="${1}" target_jar="${2}" jar
1093
1094 if [[ "${EAPI}" == "1" ]]; then
1095 pkg="${pkg//:/-}"
1096 fi
1097
1044 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 1098 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
1045 [[ -z ${target_jar} ]] && die "Must specify jar to get" 1099 [[ -z ${target_jar} ]] && die "Must specify jar to get"
1046 1100
1047 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?" 1101 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
1048 local classpath 1102 local classpath
1049 classpath=$(java-config --classpath=${pkg}) 1103 classpath=$(java-config --classpath=${pkg})
1050 [[ $? != 0 ]] && die ${error_msg} 1104 [[ $? != 0 ]] && die ${error_msg}
1051 1105
1052 java-pkg_ensure-dep "${build_only}" "${pkg}" 1106 java-pkg_ensure-dep "${build_only}" "${pkg}"
1107
1108 # Record the package(Virtual) as a dependency and then set build_only
1109 # So that individual jars are not recorded.
1110 if [[ -n "${virtual}" ]]; then
1111 java-pkg_record-jar_ "${pkg}"
1112 build_only="true"
1113 fi
1053 1114
1054 for jar in ${classpath//:/ }; do 1115 for jar in ${classpath//:/ }; do
1055 if [[ ! -f "${jar}" ]] ; then 1116 if [[ ! -f "${jar}" ]] ; then
1056 die "Installation problem with jar ${jar} in ${pkg} - is it installed?" 1117 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1057 fi 1118 fi
1064 fi 1125 fi
1065 done 1126 done
1066 1127
1067 die "Could not find ${target_jar} in ${pkg}" 1128 die "Could not find ${target_jar} in ${pkg}"
1068 return 1 1129 return 1
1130}
1131
1132# ------------------------------------------------------------------------------
1133# @ebuild-function java-pkg_register-dependency
1134#
1135# Registers runtime dependency on a package, list of packages, or a single jar
1136# from a package, into package.env DEPEND line. Can only be called in
1137# src_install phase.
1138# Intended for binary packages where you don't need to symlink the jars or get
1139# their classpath during build. As such, the dependencies only need to be
1140# specified in ebuild's RDEPEND, and should be omitted in DEPEND.
1141#
1142# @param $1 - comma-separated list of packages, or a single package
1143# @param $2 - if param $1 is a single package, optionally specify the jar
1144# to depend on
1145#
1146# Example: Record the dependency on whole xerces-2 and xalan,
1147# java-pkg_register-dependency xerces-2,xalan
1148# Example: Record the dependency on ant.jar from ant-core
1149# java-pkg_register-dependency ant-core ant.jar
1150#
1151# Note: Passing both list of packages as the first parameter AND specifying the
1152# jar as the second is not allowed and will cause the function to die. We assume
1153# that there's more chance one passes such combination as a mistake, than that
1154# there are more packages providing identically named jar without class
1155# collisions.
1156# ------------------------------------------------------------------------------
1157java-pkg_register-dependency() {
1158 debug-print-function ${FUNCNAME} $*
1159
1160 java-pkg_check-phase install
1161
1162 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1163
1164 local pkgs="${1}"
1165 local jar="${2}"
1166
1167 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1168
1169 if [[ "${EAPI}" == "1" ]]; then
1170 pkgs="${pkgs//:/-}"
1171 fi
1172
1173 if [[ -z "${jar}" ]]; then
1174 for pkg in ${pkgs//,/ }; do
1175 java-pkg_ensure-dep runtime "${pkg}"
1176 java-pkg_record-jar_ "${pkg}"
1177 done
1178 else
1179 [[ ${pkgs} == *,* ]] && \
1180 die "${FUNCNAME} called with both package list and jar name"
1181 java-pkg_ensure-dep runtime "${pkgs}"
1182 java-pkg_record-jar_ "${pkgs}" "${jar}"
1183 fi
1184
1185 java-pkg_do_write_
1186}
1187
1188# ------------------------------------------------------------------------------
1189# @ebuild-function java-pkg_register-optional-dependency
1190#
1191# Registers optional runtime dependency on a package, list of packages, or a
1192# single jar from a package, into package.env OPTIONAL_DEPEND line. Can only be
1193# called in src_install phase.
1194# Intended for packages that can use other packages when those are in classpath.
1195# Will be put on classpath by launcher if they are installed. Typical case is
1196# JDBC implementations for various databases. It's better than having USE flag
1197# for each implementation triggering hard dependency.
1198#
1199# @param $1 - comma-separated list of packages, or a single package
1200# @param $2 - if param $1 is a single package, optionally specify the jar
1201# to depend on
1202#
1203# Example: Record the optional dependency on some jdbc providers
1204# java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1205#
1206# Note: Passing both list of packages as the first parameter AND specifying the
1207# jar as the second is not allowed and will cause the function to die. We assume
1208# that there's more chance one passes such combination as a mistake, than that
1209# there are more packages providing identically named jar without class
1210# collisions.
1211# ------------------------------------------------------------------------------
1212java-pkg_register-optional-dependency() {
1213 debug-print-function ${FUNCNAME} $*
1214
1215 java-pkg_check-phase install
1216
1217 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1218
1219 local pkgs="${1}"
1220 local jar="${2}"
1221
1222 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1223
1224 if [[ "${EAPI}" == "1" ]]; then
1225 pkgs="${pkgs//:/-}"
1226 fi
1227
1228 if [[ -z "${jar}" ]]; then
1229 for pkg in ${pkgs//,/ }; do
1230 java-pkg_record-jar_ --optional "${pkg}"
1231 done
1232 else
1233 [[ ${pkgs} == *,* ]] && \
1234 die "${FUNCNAME} called with both package list and jar name"
1235 java-pkg_record-jar_ --optional "${pkgs}" "${jar}"
1236 fi
1237
1238 java-pkg_do_write_
1239}
1240
1241# ------------------------------------------------------------------------------
1242# @ebuild-function java-pkg_register-environment-variable
1243#
1244# Register an arbitrary environment variable into package.env. The gjl launcher
1245# for this package or any package depending on this will export it into
1246# environement before executing java command.
1247# Must only be called in src_install phase.
1248#
1249# @param $1 - variable name
1250# @param $2 - variable value
1251# ------------------------------------------------------------------------------
1252JAVA_PKG_EXTRA_ENV="${T}/java-pkg-extra-env"
1253JAVA_PKG_EXTRA_ENV_VARS=""
1254java-pkg_register-environment-variable() {
1255 debug-print-function ${FUNCNAME} $*
1256
1257 java-pkg_check-phase install
1258
1259 [[ ${#} != 2 ]] && die "${FUNCNAME} takes two arguments"
1260
1261 echo "${1}=\"${2}\"" >> ${JAVA_PKG_EXTRA_ENV}
1262 JAVA_PKG_EXTRA_ENV_VARS="${JAVA_PKG_EXTRA_ENV_VARS} ${1}"
1263
1264 java-pkg_do_write_
1069} 1265}
1070 1266
1071# This function reads stdin, and based on that input, figures out how to 1267# This function reads stdin, and based on that input, figures out how to
1072# populate jars from the filesystem. 1268# populate jars from the filesystem.
1073# Need to figure out a good way of making use of this, ie be able to use a 1269# Need to figure out a good way of making use of this, ie be able to use a
1536 dodir /usr/share/ant/${TASKS_DIR} 1732 dodir /usr/share/ant/${TASKS_DIR}
1537 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}" 1733 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1538} 1734}
1539 1735
1540# ------------------------------------------------------------------------------ 1736# ------------------------------------------------------------------------------
1541# @internal-function java-pkg_ant-tasks-from-deps
1542#
1543# Function to determine ANT_TASKS from DEPEND variable for backwards
1544# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1545# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1546# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1547# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1548# be a problem, the worst it can do is activace all tasks when not needed.
1549# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1550# insufficient dependencies, otherwise all available tasks are used for
1551# backwards compatilbility.
1552#
1553# @return "all" or "none"
1554# ------------------------------------------------------------------------------
1555java-pkg_ant-tasks-from-deps() {
1556 local found_ant found_ant_tasks
1557
1558 for dep in ${DEPEND}
1559 do
1560 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1561 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1562 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1563 done
1564
1565 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1566 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1567 echo "all"
1568 else
1569 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1570 # so we deactivate all tasks that may be installed
1571 echo "none"
1572 fi
1573}
1574
1575# ------------------------------------------------------------------------------
1576# @internal-function java-pkg_ant-tasks-depend 1737# @internal-function java-pkg_ant-tasks-depend
1577# 1738#
1578# Translates the WANT_ANT_TASKS variable into valid dependencies. 1739# Translates the WANT_ANT_TASKS variable into valid dependencies.
1579# ------------------------------------------------------------------------------ 1740# ------------------------------------------------------------------------------
1580java-pkg_ant-tasks-depend() { 1741java-pkg_ant-tasks-depend() {
1596 return 0 1757 return 0
1597 fi 1758 fi
1598} 1759}
1599 1760
1600# ------------------------------------------------------------------------------ 1761# ------------------------------------------------------------------------------
1762# @ebuild-function ejunit
1763#
1764# Junit wrapper function. Makes it easier to run the tests and checks for
1765# dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1766#
1767# Examples:
1768# ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1769# ejunit org.blinkenlights.jid3.test.AllTests
1770#
1771# @param $1 - -cp or -classpath
1772# @param $2 - classpath; junit and recorded dependencies get appended
1773# @param $@ - the rest of the parameters are passed to java
1774# ------------------------------------------------------------------------------
1775ejunit() {
1776 debug-print-function ${FUNCNAME} $*
1777
1778 local pkgs
1779 if [[ -f ${JAVA_PKG_DEPEND_FILE} ]]; then
1780 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1781 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1782 done
1783 fi
1784
1785 local cp=$(java-pkg_getjars --with-dependencies junit${pkgs})
1786 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1787 cp="${2}:${cp}"
1788 shift 2
1789 else
1790 cp=".:${cp}"
1791 fi
1792
1793 local runner=junit.textui.TestRunner
1794 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1795 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1796}
1797
1798# ------------------------------------------------------------------------------
1601# @section-end helper 1799# @section-end helper
1602# ------------------------------------------------------------------------------ 1800# ------------------------------------------------------------------------------
1603 1801
1604# ------------------------------------------------------------------------------ 1802# ------------------------------------------------------------------------------
1605# @section-begin build 1803# @section-begin build
1616# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS, 1814# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1617# variables: 1815# variables:
1618# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the 1816# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1619# gentoo.classpath property. Be sure to call 1817# gentoo.classpath property. Be sure to call
1620# java-ant_rewrite-classpath in src_unpack. 1818# java-ant_rewrite-classpath in src_unpack.
1819# JAVA_PKG_NO_BUNDLED_SEARCH - Don't search for bundled jars or class files
1621# *ANT_TASKS - used to determine ANT_TASKS before calling Ant. 1820# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1622# ------------------------------------------------------------------------------ 1821# ------------------------------------------------------------------------------
1623eant() { 1822eant() {
1624 debug-print-function ${FUNCNAME} $* 1823 debug-print-function ${FUNCNAME} $*
1625 1824
1626 # FIXME get this working 1825 if [[ ${EBUILD_PHASE} = compile ]]; then
1627# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1826 # Used to be done in hooks in java-ant-2.eclass but moved here so that we can
1628# java-pkg_announce-qa-violation \ 1827 # finally get rid of the hooks without breaking stuff
1629# "Using eant, but not depending on dev-java/ant or dev-java/ant-core" 1828
1829 [[ "${JAVA_ANT_IGNORE_SYSTEM_CLASSES}" && "${JAVA_PKG_BSFIX}" ]] \
1830 && java-ant_ignore-system-classes "${S}/build.xml"
1831
1832 if hasq java-ant-2 ${INHERITED}; then
1833 java-ant_bsfix
1834 fi
1835
1836 # eant can be called multiple times
1837 JAVA_PKG_BSFIX="off"
1838
1839 if [[ -z ${JAVA_PKG_NO_BUNDLED_SEARCH} ]] && is-java-strict; then
1840 echo "Searching for bundled jars:"
1841 java-pkg_find-normal-jars || echo "None found."
1842 echo "Searching for bundled classes (no output if none found):"
1843 find "${WORKDIR}" -name "*.class"
1844 echo "Search done."
1845 JAVA_PKG_NO_BUNDLED_SEARCH=true # eant can be called many times
1846 fi
1630# fi 1847 fi
1631 1848
1632 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then 1849 if ! hasq java-ant-2 ${INHERITED}; then
1633 local msg="You should inherit java-ant-2 when using eant" 1850 local msg="You should inherit java-ant-2 when using eant"
1634 java-pkg_announce-qa-violation ${msg} 1851 java-pkg_announce-qa-violation "${msg}"
1635 die ${msg}
1636 fi 1852 fi
1637 1853
1638 local antflags="-Dnoget=true -Dmaven.mode.offline=true" 1854 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1639 1855
1640 java-pkg_init-compiler_ 1856 java-pkg_init-compiler_
1641 local compiler="${GENTOO_COMPILER}" 1857 local compiler="${GENTOO_COMPILER}"
1642 1858
1643 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1859 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1644
1645 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})" 1860 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1646 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1861 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1647 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1862 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1648 fi 1863 fi
1649 1864
1655 # java-config -p 1870 # java-config -p
1656 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1871 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1657 if [[ -n ${build_compiler_deps} ]]; then 1872 if [[ -n ${build_compiler_deps} ]]; then
1658 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})" 1873 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1659 fi 1874 fi
1660 fi
1661
1662 if is-java-strict; then
1663 einfo "Disabling system classpath for ant"
1664 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1665 fi 1875 fi
1666 1876
1667 for arg in "${@}"; do 1877 for arg in "${@}"; do
1668 if [[ ${arg} = -lib ]]; then 1878 if [[ ${arg} = -lib ]]; then
1669 if is-java-strict; then 1879 if is-java-strict; then
1678 echo "more info." 1888 echo "more info."
1679 fi 1889 fi
1680 fi 1890 fi
1681 done 1891 done
1682 1892
1683 if has_version ">=dev-java/ant-core-1.7.0"; then
1684 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly 1893 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1685 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}" 1894 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}"
1686 1895
1687 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set 1896 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1688 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}" 1897 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1689 1898
1690 if is-java-strict; then
1691 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1692 if [[ -z "${ANT_TASKS}" ]]; then
1693 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1694 fi
1695 else
1696 # if ant-tasks is not set by ebuild or forced, activate all of them 1899 # if ant-tasks is not set by ebuild or forced, use none
1697 ANT_TASKS="${ANT_TASKS:-all}" 1900 ANT_TASKS="${ANT_TASKS:-none}"
1698 fi
1699 1901
1700 # at this point, ANT_TASKS should be "all", "none" or explicit list 1902 # at this point, ANT_TASKS should be "all", "none" or explicit list
1701 if [[ "${ANT_TASKS}" == "all" ]]; then 1903 if [[ "${ANT_TASKS}" == "all" ]]; then
1702 einfo "Using all available ANT_TASKS" 1904 einfo "Using all available ANT_TASKS"
1703 elif [[ "${ANT_TASKS}" == "none" ]]; then 1905 elif [[ "${ANT_TASKS}" == "none" ]]; then
1704 einfo "Disabling all optional ANT_TASKS" 1906 einfo "Disabling all optional ANT_TASKS"
1705 else 1907 else
1706 einfo "Using following ANT_TASKS: ${ANT_TASKS}" 1908 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1707 fi 1909 fi
1708 1910
1709 export ANT_TASKS 1911 export ANT_TASKS
1710 fi
1711 1912
1712 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug" 1913 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1713 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q" 1914 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1714 1915
1715 local gcp="${EANT_GENTOO_CLASSPATH}" 1916 local gcp="${EANT_GENTOO_CLASSPATH}"
1917 local getjarsarg=""
1716 1918
1717 if [[ ${EBUILD_PHASE} = "test" ]]; then 1919 if [[ ${EBUILD_PHASE} = "test" ]]; then
1718 antflags="${antflags} -DJunit.present=true" 1920 antflags="${antflags} -DJunit.present=true"
1719 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit" 1921 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit"
1720 local getjarsarg="--with-dependencies" 1922 getjarsarg="--with-dependencies"
1721 fi 1923 fi
1722 1924
1723 local cp 1925 local cp
1724 1926
1725 for atom in ${gcp}; do 1927 for atom in ${gcp}; do
1836# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will 2038# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
1837# call it during each of the phases of the merge process. 2039# call it during each of the phases of the merge process.
1838# 2040#
1839# ----------------------------------------------------------------------------- 2041# -----------------------------------------------------------------------------
1840java-pkg_init() { 2042java-pkg_init() {
2043 debug-print-function ${FUNCNAME} $*
1841 unset JAVAC 2044 unset JAVAC
1842 unset JAVA_HOME 2045 unset JAVA_HOME
1843 2046
1844 # People do all kinds of weird things. 2047 # People do all kinds of weird things.
1845 # http://forums.gentoo.org/viewtopic-p-3943166.html 2048 # http://forums.gentoo.org/viewtopic-p-3943166.html
1853 ewarn "make.conf for example) to silence this warning or" 2056 ewarn "make.conf for example) to silence this warning or"
1854 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it." 2057 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
1855 fi 2058 fi
1856 2059
1857 if [[ -z ${accept} ]]; then 2060 if [[ -z ${accept} ]]; then
2061 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2062 # -version output
1858 unset _JAVA_OPTIONS 2063 unset _JAVA_OPTIONS
1859 # phase hooks make this run many times without this 2064 # phase hooks make this run many times without this
1860 I_WANT_GLOBAL_JAVA_OPTIONS="true" 2065 I_WANT_GLOBAL_JAVA_OPTIONS="true"
1861 fi 2066 fi
1862 2067
2068 if java-pkg_func-exists ant_src_unpack; then
2069 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2070 fi
2071
1863 java-pkg_init_paths_ 2072 java-pkg_init_paths_
1864 java-pkg_switch-vm 2073 java-pkg_switch-vm
1865 PATH=${JAVA_HOME}/bin:${PATH} 2074 PATH=${JAVA_HOME}/bin:${PATH}
1866 2075
1867 # TODO we will probably want to set JAVAC and JAVACFLAGS 2076 # TODO we will probably want to set JAVAC and JAVACFLAGS
1868 2077
1869 # Do some QA checks 2078 # Do some QA checks
1870 java-pkg_check-jikes 2079 java-pkg_check-jikes
2080
2081 # Can't use unset here because Portage does not save the unset
2082 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
1871 2083
1872 # When users have crazy classpaths some packages can fail to compile. 2084 # When users have crazy classpaths some packages can fail to compile.
1873 # and everything should work with empty CLASSPATH. 2085 # and everything should work with empty CLASSPATH.
1874 # This also helps prevent unexpected dependencies on random things 2086 # This also helps prevent unexpected dependencies on random things
1875 # from the CLASSPATH. 2087 # from the CLASSPATH.
1876 unset CLASSPATH 2088 export CLASSPATH=
1877 2089
1878 # Unset external ANT_ stuff 2090 # Unset external ANT_ stuff
1879 unset ANT_TASKS 2091 export ANT_TASKS=
1880 unset ANT_OPTS 2092 export ANT_OPTS=
1881} 2093}
1882 2094
1883# ------------------------------------------------------------------------------ 2095# ------------------------------------------------------------------------------
1884# @function-internal java-pkg-init-compiler_ 2096# @function-internal java-pkg-init-compiler_
1885# 2097#
1976 done 2188 done
1977 2189
1978 # If it hasn't been defined already, default to javac 2190 # If it hasn't been defined already, default to javac
1979 if [[ -z ${GENTOO_COMPILER} ]]; then 2191 if [[ -z ${GENTOO_COMPILER} ]]; then
1980 if [[ -n ${compilers} ]]; then 2192 if [[ -n ${compilers} ]]; then
1981 einfo "No suitable compiler found: defaulting javac for compilation" 2193 einfo "No suitable compiler found: defaulting to JDK default for compilation"
1982 else 2194 else
1983 # probably don't need to notify users about the default. 2195 # probably don't need to notify users about the default.
1984 :;#einfo "Defaulting to javac for compilation" 2196 :;#einfo "Defaulting to javac for compilation"
1985 fi 2197 fi
2198 if java-config -g GENTOO_COMPILER 2> /dev/null; then
2199 export GENTOO_COMPILER=$(java-config -g GENTOO_COMPILER)
2200 else
1986 export GENTOO_COMPILER=javac 2201 export GENTOO_COMPILER=javac
2202 fi
1987 else 2203 else
1988 einfo "Using ${GENTOO_COMPILER} for compilation" 2204 einfo "Using ${GENTOO_COMPILER} for compilation"
1989 fi 2205 fi
1990 2206
1991} 2207}
2007 fi 2223 fi
2008 2224
2009 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}" 2225 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
2010 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/" 2226 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
2011 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env" 2227 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2228 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2229 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2012 2230
2013 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib" 2231 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2014 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}" 2232 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2015 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps" 2233 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2016 2234
2029# Writes the package.env out to disk. 2247# Writes the package.env out to disk.
2030# 2248#
2031# ------------------------------------------------------------------------------ 2249# ------------------------------------------------------------------------------
2032# TODO change to do-write, to match everything else 2250# TODO change to do-write, to match everything else
2033java-pkg_do_write_() { 2251java-pkg_do_write_() {
2252 debug-print-function ${FUNCNAME} $*
2034 java-pkg_init_paths_ 2253 java-pkg_init_paths_
2035 # Create directory for package.env 2254 # Create directory for package.env
2036 dodir "${JAVA_PKG_SHAREPATH}" 2255 dodir "${JAVA_PKG_SHAREPATH}"
2037 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 2256 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2257 "${JAVA_PKG_DEPEND_FILE}" || -f \
2258 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2038 # Create package.env 2259 # Create package.env
2039 ( 2260 (
2040 echo "DESCRIPTION=\"${DESCRIPTION}\"" 2261 echo "DESCRIPTION=\"${DESCRIPTION}\""
2041 echo "GENERATION=\"2\"" 2262 echo "GENERATION=\"2\""
2263 echo "SLOT=\"${SLOT}\""
2042 2264
2043 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\"" 2265 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2044 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 2266 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2045 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 2267 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2046 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 2268 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2269 && echo "DEPEND=\"$(cat "${JAVA_PKG_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2270 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2271 && echo "OPTIONAL_DEPEND=\"$(cat "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2047 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 2272 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2048 ) > "${JAVA_PKG_ENV}" 2273 ) > "${JAVA_PKG_ENV}"
2049 2274
2050 # register target/source 2275 # register target/source
2051 local target="$(java-pkg_get-target)" 2276 local target="$(java-pkg_get-target)"
2062 2287
2063 2288
2064 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}" 2289 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2065 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}" 2290 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2066 2291
2292 # extra env variables
2293 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2294 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2295 # nested echo to remove leading/trailing spaces
2296 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2297 >> "${JAVA_PKG_ENV}" || die
2298 fi
2299
2067 # Strip unnecessary leading and trailing colons 2300 # Strip unnecessary leading and trailing colons
2068 # TODO try to cleanup if possible 2301 # TODO try to cleanup if possible
2069 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 2302 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2303 else
2304 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2305 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2306 debug-print "write package.env."
2070 fi 2307 fi
2071} 2308}
2072 2309
2073# ------------------------------------------------------------------------------ 2310# ------------------------------------------------------------------------------
2074# @internal-function java-pkg_record-jar_ 2311# @internal-function java-pkg_record-jar_
2075# 2312#
2076# Record a dependency to the package.env 2313# Record an (optional) dependency to the package.env
2077# 2314# @param --optional - record dependency as optional
2315# @param $1 - package to record
2316# @param $2 - (optional) jar of package to record
2078# ------------------------------------------------------------------------------ 2317# ------------------------------------------------------------------------------
2079JAVA_PKG_DEPEND="${T}/java-pkg-depend" 2318JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2319JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2080 2320
2081java-pkg_record-jar_() { 2321java-pkg_record-jar_() {
2082 debug-print-function ${FUNCNAME} $* 2322 debug-print-function ${FUNCNAME} $*
2323
2324 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2325 if [[ "${1}" == "--optional" ]]; then
2326 depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"
2327 shift
2328 fi
2083 2329
2084 local pkg=${1} jar=${2} append 2330 local pkg=${1} jar=${2} append
2085 if [[ -z "${jar}" ]]; then 2331 if [[ -z "${jar}" ]]; then
2086 append="${pkg}" 2332 append="${pkg}"
2087 else 2333 else
2088 append="$(basename ${jar})@${pkg}" 2334 append="$(basename ${jar})@${pkg}"
2089 fi 2335 fi
2090 2336
2091 echo ${append} >> ${JAVA_PKG_DEPEND} 2337 echo "${append}" >> "${depend_file}"
2092} 2338}
2093 2339
2094# ------------------------------------------------------------------------------ 2340# ------------------------------------------------------------------------------
2095# @internal-function java-pkg_append_ 2341# @internal-function java-pkg_append_
2096# 2342#
2156# 2402#
2157# ------------------------------------------------------------------------------ 2403# ------------------------------------------------------------------------------
2158java-pkg_setup-vm() { 2404java-pkg_setup-vm() {
2159 debug-print-function ${FUNCNAME} $* 2405 debug-print-function ${FUNCNAME} $*
2160 2406
2407 export LANG="C" LC_ALL="C"
2408
2161 local vendor="$(java-pkg_get-vm-vendor)" 2409 local vendor="$(java-pkg_get-vm-vendor)"
2162 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then 2410 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2163 addpredict "/dev/random" 2411 addpredict "/dev/random"
2164 elif [[ "${vendor}" == "ibm" ]]; then 2412 elif [[ "${vendor}" == "ibm" ]]; then
2165 addpredict "/proc/self/maps" 2413 addpredict "/proc/self/maps"
2166 addpredict "/proc/cpuinfo" 2414 addpredict "/proc/cpuinfo"
2167 export LANG="C" LC_ALL="C"
2168 elif [[ "${vendor}" == "jrockit" ]]; then 2415 elif [[ "${vendor}" == "jrockit" ]]; then
2169 addpredict "/proc/cpuinfo" 2416 addpredict "/proc/cpuinfo"
2170 fi 2417 fi
2171} 2418}
2172 2419
2276 2523
2277 #TODO If you know a better solution let us know. 2524 #TODO If you know a better solution let us know.
2278 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2525 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2279 2526
2280 local tann="${T}/announced-vm" 2527 local tann="${T}/announced-vm"
2528 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2529 # if people have for example modified eclasses some where
2281 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2530 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2282 # Add a check for setup/preinst phase... to avoid duplicate outputs
2283 # for when FEATURES=buildpkg
2284 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
2285 then
2286 einfo "Using: $(java-config -f)" 2531 einfo "Using: $(java-config -f)"
2287 [[ ! -f "${tann}" ]] && touch "${tann}" 2532 [[ ! -f "${tann}" ]] && touch "${tann}"
2288 fi
2289 fi 2533 fi
2290 2534
2291 else 2535 else
2292 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!" 2536 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2293 fi 2537 fi
2357 2601
2358# ---------------------------------------------------------------------------- 2602# ----------------------------------------------------------------------------
2359# @internal-function java-pkg_ensure-dep 2603# @internal-function java-pkg_ensure-dep
2360# Check that a package being used in jarfrom, getjars and getjar is contained 2604# Check that a package being used in jarfrom, getjars and getjar is contained
2361# within DEPEND or RDEPEND. 2605# within DEPEND or RDEPEND.
2362# @param $1 - Is the package a runtime dependency 2606# @param $1 - empty - check both vars; "runtime" or "build" - check only
2607# RDEPEND, resp. DEPEND
2363# @param $2 - Package name and slot. 2608# @param $2 - Package name and slot.
2364 2609
2365java-pkg_ensure-dep() { 2610java-pkg_ensure-dep() {
2366 debug-print-function ${FUNCNAME} $* 2611 debug-print-function ${FUNCNAME} $*
2367 2612
2368 local build_only="${1}" 2613 local limit_to="${1}"
2369 local target_pkg="${2}" 2614 local target_pkg="${2}"
2370 local dev_error="" 2615 local dev_error=""
2371 2616
2372 local stripped_pkg=$(echo "${target_pkg}" | sed \ 2617 local stripped_pkg=$(echo "${target_pkg}" | sed \
2373 's/-[0-9]*\(\.[0-9]\)*$//') 2618 's/-[0-9]*\(\.[0-9]\)*$//')
2374 2619
2620 debug-print "Matching against: ${stripped_pkg}"
2621
2375 if [[ ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then 2622 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then
2376 dev_error="The ebuild is attempting to use ${target_pkg} that is not" 2623 dev_error="The ebuild is attempting to use ${target_pkg} that is not"
2377 dev_error="${dev_error} declared in DEPEND." 2624 dev_error="${dev_error} declared in DEPEND."
2378 if is-java-strict; then 2625 if is-java-strict; then
2626 eerror "${dev_error}"
2379 die "${dev_error}" 2627 die "${dev_error}"
2380 elif [[ ${BASH_SUBSHELL} = 0 ]]; then 2628 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2381 eerror "${dev_error}" 2629 eerror "${dev_error}"
2382 elog "Because you have this package installed the package will" 2630 elog "Because you have this package installed the package will"
2383 elog "build without problems, but please report this to" 2631 elog "build without problems, but please report this to"
2384 elog "http://bugs.gentoo.org" 2632 elog "http://bugs.gentoo.org"
2385 fi 2633 fi
2386 fi 2634 fi
2387 2635
2636 if [[ ${limit_to} != build ]]; then
2388 if [[ -z ${build_only} && ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then 2637 if [[ ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then
2638 if [[ ! ( ${PDEPEND} =~ "${stripped_pkg}" ) ]]; then
2389 dev_error="The ebuild is attempting to use ${target_pkg}," 2639 dev_error="The ebuild is attempting to use ${target_pkg},"
2390 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND." 2640 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND"
2641 dev_error="${dev_error} or PDEPEND."
2391 if is-java-strict; then 2642 if is-java-strict; then
2643 eerror "${dev_error}"
2392 die "${dev_error}" 2644 die "${dev_error}"
2393 elif [[ ${BASH_SUBSHELL} = 0 ]]; then 2645 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2394 eerror "${dev_error}" 2646 eerror "${dev_error}"
2395 elog "Because you have this package installed the package will" 2647 elog "The package will build without problems, but may fail to run"
2396 elog "build without problems, but please report this to" 2648 elog "if you don't have ${target_pkg} installed, so please report"
2397 elog "http://bugs.gentoo.org" 2649 elog "this to http://bugs.gentoo.org"
2650 fi
2651 fi
2398 fi 2652 fi
2399 fi 2653 fi
2400} 2654}
2401 2655
2402# ------------------------------------------------------------------------------ 2656# ------------------------------------------------------------------------------
2403# @section-end internal 2657# @section-end internal
2404# ------------------------------------------------------------------------------ 2658# ------------------------------------------------------------------------------
2405 2659
2406java-pkg_check-phase() { 2660java-pkg_check-phase() {
2407 local phase=${1} 2661 local phase=${1}
2408 local funcname=${2} 2662 local funcname=${FUNCNAME[1]}
2409 if is-java-strict && [[ ${EBUILD_PHASE} != ${phase} ]]; then 2663 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2410 java-pkg_announce-qa-violation \
2411 "${funcname} used outside of src_${phase}" 2664 local msg="${funcname} used outside of src_${phase}"
2665 java-pkg_announce-qa-violation "${msg}"
2412 fi 2666 fi
2413} 2667}
2414 2668
2415java-pkg_check-versioned-jar() { 2669java-pkg_check-versioned-jar() {
2416 local jar=${1} 2670 local jar=${1}
2425 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE" 2679 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2426 fi 2680 fi
2427} 2681}
2428 2682
2429java-pkg_announce-qa-violation() { 2683java-pkg_announce-qa-violation() {
2430 if is-java-strict; then 2684 local nodie
2685 if [[ ${1} == "--nodie" ]]; then
2686 nodie="true"
2687 shift
2688 fi
2431 echo "Java QA Notice: $@" >&2 2689 echo "Java QA Notice: $@" >&2
2432 increment-qa-violations 2690 increment-qa-violations
2433 fi 2691 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2434} 2692}
2435 2693
2436increment-qa-violations() { 2694increment-qa-violations() {
2437 let "JAVA_PKG_QA_VIOLATIONS+=1" 2695 let "JAVA_PKG_QA_VIOLATIONS+=1"
2438 export JAVA_PKG_QA_VIOLATIONS 2696 export JAVA_PKG_QA_VIOLATIONS

Legend:
Removed from v.1.75  
changed lines
  Added in v.1.107

  ViewVC Help
Powered by ViewVC 1.1.20