/[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.70 Revision 1.113
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.70 2007/04/17 09:16:22 ali_bush Exp $ 9# $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.113 2008/10/01 15:23:17 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"
283 done 291 done
284 292
285 java-pkg_do_write_ 293 java-pkg_do_write_
286} 294}
287 295
288
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.
293# Using env variables keeps this eclass working with java-config versions that 300# Using env variables keeps this eclass working with java-config versions that
438 if [[ -e "${lib}" ]] ; then 445 if [[ -e "${lib}" ]] ; then
439 # install if it isn't a symlink 446 # install if it isn't a symlink
440 if [[ ! -L "${lib}" ]] ; then 447 if [[ ! -L "${lib}" ]] ; then
441 INSDESTTREE="${JAVA_PKG_LIBDEST}" \ 448 INSDESTTREE="${JAVA_PKG_LIBDEST}" \
442 INSOPTIONS="${LIBOPTIONS}" \ 449 INSOPTIONS="${LIBOPTIONS}" \
443 doins "${lib}" || "failed to install ${lib}" 450 doins "${lib}" || die "failed to install ${lib}"
444 java-pkg_append_ JAVA_PKG_LIBRARY "${JAVA_PKG_LIBDEST}" 451 java-pkg_append_ JAVA_PKG_LIBRARY "${JAVA_PKG_LIBDEST}"
445 debug-print "Installing ${lib} to ${JAVA_PKG_LIBDEST}" 452 debug-print "Installing ${lib} to ${JAVA_PKG_LIBDEST}"
446 # otherwise make a symlink to the symlink's origin 453 # otherwise make a symlink to the symlink's origin
447 else 454 else
448 # TODO use dosym 455 # TODO use dosym
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() {
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
561 local dir="$1" 580 local dir="$1"
581 local dest=/usr/share/doc/${PF}/html
582
583 # QA checks
562 584
563 java-pkg_check-phase install 585 java-pkg_check-phase install
564 586
565 [[ -z "${dir}" ]] && die "Must specify a directory!" 587 [[ -z "${dir}" ]] && die "Must specify a directory!"
566 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!" 588 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!"
589 if [[ ! -e "${dir}/index.html" ]]; then
590 local msg="No index.html in javadoc directory"
591 ewarn "${msg}"
592 is-java-strict && die "${msg}"
593 fi
594
595 if [[ -e ${D}/${dest}/api ]]; then
596 eerror "${dest} already exists. Will not overwrite."
597 die "${dest}"
598 fi
599
600 # Renaming to match our directory layout
567 601
568 local dir_to_install="${dir}" 602 local dir_to_install="${dir}"
569 if [[ "$(basename "${dir}")" != "api" ]]; then 603 if [[ "$(basename "${dir}")" != "api" ]]; then
570 dir_to_install="${T}/api" 604 dir_to_install="${T}/api"
571 # TODO use doins 605 # TODO use doins
572 cp -r "${dir}" "${dir_to_install}" || die "cp failed" 606 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
573 fi 607 fi
574 608
609 # Actual installation
610
575 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
576} 620}
577 621
578# ------------------------------------------------------------------------------ 622# ------------------------------------------------------------------------------
579# @ebuild-function java-pkg_dosrc 623# @ebuild-function java-pkg_dosrc
580# 624#
603 647
604 [[ ${#} -lt 1 ]] && die "At least one argument needed" 648 [[ ${#} -lt 1 ]] && die "At least one argument needed"
605 649
606 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then 650 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then
607 local msg="${FUNCNAME} called without app-arch/zip in DEPEND" 651 local msg="${FUNCNAME} called without app-arch/zip in DEPEND"
608 if is-java-strict; then 652 java-pkg_announce-qa-violation ${msg}
609 eerror "${msg}"
610 die "${msg}"
611 else
612 echo "${msg}"
613 echo "Please report this to http://bugs.gentoo.org."
614 fi
615 fi 653 fi
616 654
617 java-pkg_init_paths_ 655 java-pkg_init_paths_
618 656
619 local zip_name="${PN}-src.zip" 657 local zip_name="${PN}-src.zip"
819# @param $opt 857# @param $opt
820# --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.
821# (assumed automatically when called inside src_test) 859# (assumed automatically when called inside src_test)
822# --with-dependencies - get jars also from requested package's dependencies 860# --with-dependencies - get jars also from requested package's dependencies
823# 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.
824# --into $dir - symlink jar(s) into $dir (must exist) instead of . 864# --into $dir - symlink jar(s) into $dir (must exist) instead of .
825# @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.
826# @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.
827# @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
828# symlink. Defaults to the name of the jar. 869# symlink. Defaults to the name of the jar.
829# ------------------------------------------------------------------------------ 870# ------------------------------------------------------------------------------
830# TODO could probably be cleaned up a little 871# TODO could probably be cleaned up a little
832 debug-print-function ${FUNCNAME} $* 873 debug-print-function ${FUNCNAME} $*
833 874
834 local build_only="" 875 local build_only=""
835 local destdir="." 876 local destdir="."
836 local deep="" 877 local deep=""
878 local virtual=""
837 879
838 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 880 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
839 881
840 while [[ "${1}" == --* ]]; do 882 while [[ "${1}" == --* ]]; do
841 if [[ "${1}" = "--build-only" ]]; then 883 if [[ "${1}" = "--build-only" ]]; then
842 build_only="true" 884 build_only="build"
843 elif [[ "${1}" = "--with-dependencies" ]]; then 885 elif [[ "${1}" = "--with-dependencies" ]]; then
844 deep="--with-dependencies" 886 deep="--with-dependencies"
887 elif [[ "${1}" = "--virtual" ]]; then
888 virtual="true"
845 elif [[ "${1}" = "--into" ]]; then 889 elif [[ "${1}" = "--into" ]]; then
846 destdir="${2}" 890 destdir="${2}"
847 shift 891 shift
848 else 892 else
849 die "java-pkg_jar-from called with unknown parameter: ${1}" 893 die "java-pkg_jar-from called with unknown parameter: ${1}"
853 897
854 local target_pkg="${1}" target_jar="${2}" destjar="${3}" 898 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
855 899
856 [[ -z ${target_pkg} ]] && die "Must specify a package" 900 [[ -z ${target_pkg} ]] && die "Must specify a package"
857 901
902 if [[ "${EAPI}" == "1" ]]; then
903 target_pkg="${target_pkg//:/-}"
904 fi
905
858 # default destjar to the target jar 906 # default destjar to the target jar
859 [[ -z "${destjar}" ]] && destjar="${target_jar}" 907 [[ -z "${destjar}" ]] && destjar="${target_jar}"
860 908
861 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}."
862 local classpath 910 local classpath
863 classpath="$(java-config ${deep} --classpath=${target_pkg})" 911 classpath="$(java-config ${deep} --classpath=${target_pkg})"
864 [[ $? != 0 ]] && die ${error_msg} 912 [[ $? != 0 ]] && die ${error_msg}
865 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
866 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
867 935
868 pushd ${destdir} > /dev/null \ 936 pushd ${destdir} > /dev/null \
869 || die "failed to change directory to ${destdir}" 937 || die "failed to change directory to ${destdir}"
870
871 # When we have commas this functions is called to bring jars from multiple
872 # packages. This affects recording of dependencencies because that syntax uses :
873 # if we don't change them to : gjl and java-config -d -p break
874 if [[ ${target_pkg} = *,* ]]; then
875 build_only="true"
876 java-pkg_record-jar_ ${target_pkg//,/:}
877 fi
878 938
879 local jar 939 local jar
880 for jar in ${classpath//:/ }; do 940 for jar in ${classpath//:/ }; do
881 local jar_name=$(basename "${jar}") 941 local jar_name=$(basename "${jar}")
882 if [[ ! -f "${jar}" ]] ; then 942 if [[ ! -f "${jar}" ]] ; then
945 debug-print-function ${FUNCNAME} $* 1005 debug-print-function ${FUNCNAME} $*
946 1006
947 local build_only="" 1007 local build_only=""
948 local deep="" 1008 local deep=""
949 1009
950 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1010 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
951 1011
952 while [[ "${1}" == --* ]]; do 1012 while [[ "${1}" == --* ]]; do
953 if [[ "${1}" = "--build-only" ]]; then 1013 if [[ "${1}" = "--build-only" ]]; then
954 build_only="true" 1014 build_only="build"
955 elif [[ "${1}" = "--with-dependencies" ]]; then 1015 elif [[ "${1}" = "--with-dependencies" ]]; then
956 deep="--with-dependencies" 1016 deep="--with-dependencies"
957 else 1017 else
958 die "java-pkg_jar-from called with unknown parameter: ${1}" 1018 die "java-pkg_jar-from called with unknown parameter: ${1}"
959 fi 1019 fi
961 done 1021 done
962 1022
963 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*" 1023 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
964 1024
965 1025
966 local classpath pkgs="${1}" 1026 local pkgs="${1}"
1027
1028 if [[ "${EAPI}" == "1" ]]; then
1029 pkgs="${pkgs//:/-}"
1030 fi
1031
967 jars="$(java-config ${deep} --classpath=${pkgs})" 1032 jars="$(java-config ${deep} --classpath=${pkgs})"
968 [[ $? != 0 || -z "${jars}" ]] && die "java-config --classpath=${pkgs} failed" 1033 [[ $? != 0 ]] && die "java-config --classpath=${pkgs} failed"
969 debug-print "${pkgs}:${jars}" 1034 debug-print "${pkgs}:${jars}"
970 1035
971 for pkg in "${pkgs//,/ }"; do 1036 for pkg in ${pkgs//,/ }; do
972 java-pkg_ensure-dep "${build_only}" "${pkg}" 1037 java-pkg_ensure-dep "${build_only}" "${pkg}"
973 done 1038 done
974 1039
975 if [[ -z "${classpath}" ]]; then
976 classpath="${jars}"
977 else
978 classpath="${classpath}:${jars}"
979 fi
980
981 # Only record jars that aren't build-only 1040 # Only record jars that aren't build-only
982 if [[ -z "${build_only}" ]]; then 1041 if [[ -z "${build_only}" ]]; then
983 oldifs="${IFS}"
984 IFS=","
985 for pkg in ${pkgs}; do 1042 for pkg in ${pkgs//,/ }; do
986 java-pkg_record-jar_ "${pkg}" 1043 java-pkg_record-jar_ "${pkg}"
987 done 1044 done
988 IFS="${oldifs}"
989 fi 1045 fi
990 1046
991 echo "${classpath}" 1047 echo "${jars}"
992} 1048}
993 1049
994# ------------------------------------------------------------------------------ 1050# ------------------------------------------------------------------------------
995# @ebuild-function java-pkg_getjar 1051# @ebuild-function java-pkg_getjar
996# 1052#
1005# @example-return 1061# @example-return
1006# /usr/share/xerces-2/lib/xml-apis.jar 1062# /usr/share/xerces-2/lib/xml-apis.jar
1007# 1063#
1008# @param $opt 1064# @param $opt
1009# --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.
1010# @param $1 - package to use 1068# @param $1 - package to use
1011# @param $2 - jar to get 1069# @param $2 - jar to get
1012# ------------------------------------------------------------------------------ 1070# ------------------------------------------------------------------------------
1013java-pkg_getjar() { 1071java-pkg_getjar() {
1014 debug-print-function ${FUNCNAME} $* 1072 debug-print-function ${FUNCNAME} $*
1015 1073
1016 local build_only="" 1074 local build_only=""
1075 local virtual=""
1017 1076
1018 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="true" 1077 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1019 1078
1020 while [[ "${1}" == --* ]]; do 1079 while [[ "${1}" == --* ]]; do
1021 if [[ "${1}" = "--build-only" ]]; then 1080 if [[ "${1}" = "--build-only" ]]; then
1022 build_only="true" 1081 build_only="build"
1082 elif [[ "${1}" == "--virtual" ]]; then
1083 virtual="true"
1023 else 1084 else
1024 die "java-pkg_jar-from called with unknown parameter: ${1}" 1085 die "java-pkg_getjar called with unknown parameter: ${1}"
1025 fi 1086 fi
1026 shift 1087 shift
1027 done 1088 done
1028 1089
1029 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*" 1090 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
1030 1091
1031 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
1032 [[ -z ${pkg} ]] && die "Must specify package to get a jar from" 1098 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
1033 [[ -z ${target_jar} ]] && die "Must specify jar to get" 1099 [[ -z ${target_jar} ]] && die "Must specify jar to get"
1034 1100
1035 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?"
1036 local classpath 1102 local classpath
1037 classpath=$(java-config --classpath=${pkg}) 1103 classpath=$(java-config --classpath=${pkg})
1038 [[ $? != 0 ]] && die ${error_msg} 1104 [[ $? != 0 ]] && die ${error_msg}
1039 1105
1040 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
1041 1114
1042 for jar in ${classpath//:/ }; do 1115 for jar in ${classpath//:/ }; do
1043 if [[ ! -f "${jar}" ]] ; then 1116 if [[ ! -f "${jar}" ]] ; then
1044 die "Installation problem with jar ${jar} in ${pkg} - is it installed?" 1117 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1045 fi 1118 fi
1052 fi 1125 fi
1053 done 1126 done
1054 1127
1055 die "Could not find ${target_jar} in ${pkg}" 1128 die "Could not find ${target_jar} in ${pkg}"
1056 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_
1057} 1265}
1058 1266
1059# 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
1060# populate jars from the filesystem. 1268# populate jars from the filesystem.
1061# 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
1524 dodir /usr/share/ant/${TASKS_DIR} 1732 dodir /usr/share/ant/${TASKS_DIR}
1525 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}" 1733 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1526} 1734}
1527 1735
1528# ------------------------------------------------------------------------------ 1736# ------------------------------------------------------------------------------
1529# @internal-function java-pkg_ant-tasks-from-deps
1530#
1531# Function to determine ANT_TASKS from DEPEND variable for backwards
1532# compatibility with ebuilds that don't set ANT_TASKS before calling eant() or
1533# WANT_ANT_TASKS before inheriting java-pkg-2. If the DEPEND string contains
1534# "dev-java/ant" or "dev-java/ant-tasks", then it returns "all", otherwise
1535# "none". It's not smart enough to cope with USE flag depends but that shouldn't
1536# be a problem, the worst it can do is activace all tasks when not needed.
1537# Note that this is called only with JAVA_PKG_STRICT=1, to find ebuilds with
1538# insufficient dependencies, otherwise all available tasks are used for
1539# backwards compatilbility.
1540#
1541# @return "all" or "none"
1542# ------------------------------------------------------------------------------
1543java-pkg_ant-tasks-from-deps() {
1544 local found_ant found_ant_tasks
1545
1546 for dep in ${DEPEND}
1547 do
1548 local ant="$(awk '/(dev-java\/ant)/ { if (match($1, "(dev-java/ant)((-[0-9])+|$)", m)) print m[1] }' <<< ${dep})"
1549 [[ "${ant}" == "dev-java/ant" ]] && found_ant=true
1550 [[ "${dep}" == *"ant-tasks"* ]] && found_ant_tasks=true
1551 done
1552
1553 if [[ -n "${found_ant}" || -n "${found_ant_tasks}" ]]; then
1554 java-pkg_announce-qa-violation "The ebuild DEPENDS on deprecated ant or ant-tasks"
1555 echo "all"
1556 else
1557 # ebuild doesn't set ANT_TASKS and doesn't depend on ant-tasks or ant
1558 # so we deactivate all tasks that may be installed
1559 echo "none"
1560 fi
1561}
1562
1563# ------------------------------------------------------------------------------
1564# @internal-function java-pkg_ant-tasks-depend 1737# @internal-function java-pkg_ant-tasks-depend
1565# 1738#
1566# Translates the WANT_ANT_TASKS variable into valid dependencies. 1739# Translates the WANT_ANT_TASKS variable into valid dependencies.
1567# ------------------------------------------------------------------------------ 1740# ------------------------------------------------------------------------------
1568java-pkg_ant-tasks-depend() { 1741java-pkg_ant-tasks-depend() {
1570 1743
1571 if [[ -n "${WANT_ANT_TASKS}" ]]; then 1744 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1572 local DEP="" 1745 local DEP=""
1573 for i in ${WANT_ANT_TASKS} 1746 for i in ${WANT_ANT_TASKS}
1574 do 1747 do
1575 if [[ ${i} != ant-* ]]; then 1748 if [[ ${i} = ant-* ]]; then
1749 DEP="${DEP}dev-java/${i} "
1750 elif [[ ${i} = */*:* ]]; then
1751 DEP="${DEP}${i} "
1752 else
1576 echo "Invalid atom in WANT_ANT_TASKS: ${i}" 1753 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1577 return 1 1754 return 1
1578 fi 1755 fi
1579 DEP="${DEP}dev-java/${i} "
1580 done 1756 done
1581 echo ${DEP} 1757 echo ${DEP}
1582 return 0 1758 return 0
1583 else 1759 else
1584 return 0 1760 return 0
1585 fi 1761 fi
1586} 1762}
1587 1763
1588# ------------------------------------------------------------------------------ 1764# ------------------------------------------------------------------------------
1765# @ebuild-function ejunit
1766#
1767# Junit wrapper function. Makes it easier to run the tests and checks for
1768# dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1769#
1770# Examples:
1771# ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1772# ejunit org.blinkenlights.jid3.test.AllTests
1773#
1774# @param $1 - -cp or -classpath
1775# @param $2 - classpath; junit and recorded dependencies get appended
1776# @param $@ - the rest of the parameters are passed to java
1777# ------------------------------------------------------------------------------
1778ejunit() {
1779 debug-print-function ${FUNCNAME} $*
1780
1781 local pkgs
1782 if [[ -f ${JAVA_PKG_DEPEND_FILE} ]]; then
1783 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1784 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1785 done
1786 fi
1787
1788 local cp=$(java-pkg_getjars --with-dependencies junit${pkgs})
1789 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1790 cp="${2}:${cp}"
1791 shift 2
1792 else
1793 cp=".:${cp}"
1794 fi
1795
1796 local runner=junit.textui.TestRunner
1797 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1798 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1799}
1800
1801# ------------------------------------------------------------------------------
1589# @section-end helper 1802# @section-end helper
1590# ------------------------------------------------------------------------------ 1803# ------------------------------------------------------------------------------
1804
1805# ------------------------------------------------------------------------------
1806# @eclass-src_prepare
1807#
1808# src_prepare Searches for bundled jars
1809# ------------------------------------------------------------------------------
1810
1811java-utils-2_src_prepare() {
1812 # Remember that eant will call this unless called via Portage
1813 if [[ ! -e "${T}/java-utils-2_src_prepare-run" ]] && is-java-strict; then
1814 echo "Searching for bundled jars:"
1815 java-pkg_find-normal-jars || echo "None found."
1816 echo "Searching for bundled classes (no output if none found):"
1817 find "${WORKDIR}" -name "*.class"
1818 echo "Search done."
1819 fi
1820 touch "${T}/java-utils-2_src_prepare-run"
1821}
1591 1822
1592# ------------------------------------------------------------------------------ 1823# ------------------------------------------------------------------------------
1593# @section-begin build 1824# @section-begin build
1594# @section-summary Build functions 1825# @section-summary Build functions
1595# 1826#
1604# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS, 1835# compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1605# variables: 1836# variables:
1606# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the 1837# EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1607# gentoo.classpath property. Be sure to call 1838# gentoo.classpath property. Be sure to call
1608# java-ant_rewrite-classpath in src_unpack. 1839# java-ant_rewrite-classpath in src_unpack.
1840# JAVA_PKG_NO_BUNDLED_SEARCH - Don't search for bundled jars or class files
1609# *ANT_TASKS - used to determine ANT_TASKS before calling Ant. 1841# *ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1610# ------------------------------------------------------------------------------ 1842# ------------------------------------------------------------------------------
1611eant() { 1843eant() {
1612 debug-print-function ${FUNCNAME} $* 1844 debug-print-function ${FUNCNAME} $*
1613 1845
1614 # FIXME get this working 1846 if [[ ${EBUILD_PHASE} = compile ]]; then
1615# if is-java-strict && [[ ! ${DEPEND} =~ "dev-java/ant" ]]; then 1847 java-ant-2_src_configure
1616# java-pkg_announce-qa-violation \ 1848 java-utils-2_src_prepare
1617# "Using eant, but not depending on dev-java/ant or dev-java/ant-core"
1618# fi 1849 fi
1619 1850
1620 if ! hasq java-ant-2 ${INHERITED} && is-java-strict; then 1851 if ! hasq java-ant-2 ${INHERITED}; then
1621 local msg="You should inherit java-ant-2 when using eant" 1852 local msg="You should inherit java-ant-2 when using eant"
1622 java-pkg_announce-qa-violation ${msg} 1853 java-pkg_announce-qa-violation "${msg}"
1623 die ${msg}
1624 fi 1854 fi
1625 1855
1626 local antflags="-Dnoget=true -Dmaven.mode.offline=true" 1856 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1627 1857
1628 java-pkg_init-compiler_ 1858 java-pkg_init-compiler_
1629 local compiler="${GENTOO_COMPILER}" 1859 local compiler="${GENTOO_COMPILER}"
1630 1860
1631 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}" 1861 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1632
1633 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})" 1862 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1634 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then 1863 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1635 die "ANT_BUILD_COMPILER undefined in ${compiler_env}" 1864 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1636 fi 1865 fi
1637 1866
1643 # java-config -p 1872 # java-config -p
1644 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})" 1873 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1645 if [[ -n ${build_compiler_deps} ]]; then 1874 if [[ -n ${build_compiler_deps} ]]; then
1646 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})" 1875 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1647 fi 1876 fi
1648 fi
1649
1650 if is-java-strict; then
1651 einfo "Disabling system classpath for ant"
1652 antflags="${antflags} -Dbuild.sysclasspath=ignore"
1653 fi 1877 fi
1654 1878
1655 for arg in "${@}"; do 1879 for arg in "${@}"; do
1656 if [[ ${arg} = -lib ]]; then 1880 if [[ ${arg} = -lib ]]; then
1657 if is-java-strict; then 1881 if is-java-strict; then
1666 echo "more info." 1890 echo "more info."
1667 fi 1891 fi
1668 fi 1892 fi
1669 done 1893 done
1670 1894
1671 if has_version ">=dev-java/ant-core-1.7.0"; then 1895 # parse WANT_ANT_TASKS for atoms
1672 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly 1896 local want_ant_tasks
1673 ANT_TASKS="${ANT_TASKS:-${WANT_ANT_TASKS}}" 1897 for i in ${WANT_ANT_TASKS}; do
1674 1898 if [[ ${i} = */*:* ]]; then
1675 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set 1899 i=${i#*/}
1676 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}" 1900 i=${i%:0}
1677 1901 want_ant_tasks+="${i/:/-} "
1678 if is-java-strict; then
1679 # if ant-tasks were not set by ebuild or forced, try to determine them from depends
1680 if [[ -z "${ANT_TASKS}" ]]; then
1681 ANT_TASKS="$(java-pkg_ant-tasks-from-deps)"
1682 fi
1683 else 1902 else
1903 want_ant_tasks+="${i} "
1904 fi
1905 done
1906 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1907 ANT_TASKS="${ANT_TASKS:-${want_ant_tasks% }}"
1908
1909 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1910 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1911
1684 # if ant-tasks is not set by ebuild or forced, activate all of them 1912 # if ant-tasks is not set by ebuild or forced, use none
1685 ANT_TASKS="${ANT_TASKS:-all}" 1913 ANT_TASKS="${ANT_TASKS:-none}"
1686 fi
1687 1914
1688 # at this point, ANT_TASKS should be "all", "none" or explicit list 1915 # at this point, ANT_TASKS should be "all", "none" or explicit list
1689 if [[ "${ANT_TASKS}" == "all" ]]; then 1916 if [[ "${ANT_TASKS}" == "all" ]]; then
1690 einfo "Using all available ANT_TASKS" 1917 einfo "Using all available ANT_TASKS"
1691 elif [[ "${ANT_TASKS}" == "none" ]]; then 1918 elif [[ "${ANT_TASKS}" == "none" ]]; then
1692 einfo "Disabling all optional ANT_TASKS" 1919 einfo "Disabling all optional ANT_TASKS"
1693 else 1920 else
1694 einfo "Using following ANT_TASKS: ${ANT_TASKS}" 1921 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1695 fi 1922 fi
1696 1923
1697 export ANT_TASKS 1924 export ANT_TASKS
1698 fi
1699 1925
1700 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug" 1926 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1701 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q" 1927 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1702 1928
1703 local gcp="${EANT_GENTOO_CLASSPATH}" 1929 local gcp="${EANT_GENTOO_CLASSPATH}"
1930 local getjarsarg=""
1704 1931
1705 if [[ ${EBUILD_PHASE} = "test" ]]; then 1932 if [[ ${EBUILD_PHASE} = "test" ]]; then
1706 antflags="${antflags} -DJunit.present=true" 1933 antflags="${antflags} -DJunit.present=true"
1707 [[ ${gcp} && ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit" 1934 [[ ${ANT_TASKS} = *ant-junit* ]] && gcp="${gcp} junit"
1935 getjarsarg="--with-dependencies"
1708 fi 1936 fi
1709 1937
1710 local cp 1938 local cp
1711 1939
1712 for atom in ${gcp}; do 1940 for atom in ${gcp}; do
1713 cp="${cp}:$(java-pkg_getjars ${atom})" 1941 cp="${cp}:$(java-pkg_getjars ${getjarsarg} ${atom})"
1714 done 1942 done
1715 1943
1716 if [[ ${cp} ]]; then 1944 if [[ ${cp} ]]; then
1717 # It seems ant does not like single quotes around ${cp} 1945 # It seems ant does not like single quotes around ${cp}
1946 cp=${cp#:}
1947 [[ ${EANT_GENTOO_CLASSPATH_EXTRA} ]] && \
1948 cp="${cp}:${EANT_GENTOO_CLASSPATH_EXTRA}"
1718 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\"" 1949 antflags="${antflags} -Dgentoo.classpath=\"${cp}\""
1719 fi 1950 fi
1720 1951
1721 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}" 1952 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1722 debug-print "Calling ant: ${antflags} ${@}" 1953 debug-print "Calling ant (GENTOO_VM: ${GENTOO_VM}): ${antflags} ${@}"
1723 ant ${antflags} "${@}" || die "eant failed" 1954 ant ${antflags} "${@}" || die "eant failed"
1724
1725} 1955}
1726 1956
1727# ------------------------------------------------------------------------------ 1957# ------------------------------------------------------------------------------
1728# @ebuild-function ejavac 1958# @ebuild-function ejavac
1729# 1959#
1824# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will 2054# This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
1825# call it during each of the phases of the merge process. 2055# call it during each of the phases of the merge process.
1826# 2056#
1827# ----------------------------------------------------------------------------- 2057# -----------------------------------------------------------------------------
1828java-pkg_init() { 2058java-pkg_init() {
2059 debug-print-function ${FUNCNAME} $*
1829 unset JAVAC 2060 unset JAVAC
1830 unset JAVA_HOME 2061 unset JAVA_HOME
1831 2062
1832 # People do all kinds of weird things. 2063 # People do all kinds of weird things.
1833 # http://forums.gentoo.org/viewtopic-p-3943166.html 2064 # http://forums.gentoo.org/viewtopic-p-3943166.html
1841 ewarn "make.conf for example) to silence this warning or" 2072 ewarn "make.conf for example) to silence this warning or"
1842 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it." 2073 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
1843 fi 2074 fi
1844 2075
1845 if [[ -z ${accept} ]]; then 2076 if [[ -z ${accept} ]]; then
2077 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2078 # -version output
1846 unset _JAVA_OPTIONS 2079 unset _JAVA_OPTIONS
1847 # phase hooks make this run many times without this 2080 # phase hooks make this run many times without this
1848 I_WANT_GLOBAL_JAVA_OPTIONS="true" 2081 I_WANT_GLOBAL_JAVA_OPTIONS="true"
1849 fi 2082 fi
1850 2083
2084 if java-pkg_func-exists ant_src_unpack; then
2085 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2086 fi
2087
1851 java-pkg_init_paths_ 2088 java-pkg_init_paths_
1852 java-pkg_switch-vm 2089 java-pkg_switch-vm
1853 PATH=${JAVA_HOME}/bin:${PATH} 2090 PATH=${JAVA_HOME}/bin:${PATH}
1854 2091
1855 # TODO we will probably want to set JAVAC and JAVACFLAGS 2092 # TODO we will probably want to set JAVAC and JAVACFLAGS
1856 2093
1857 # Do some QA checks 2094 # Do some QA checks
1858 java-pkg_check-jikes 2095 java-pkg_check-jikes
2096
2097 # Can't use unset here because Portage does not save the unset
2098 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
1859 2099
1860 # When users have crazy classpaths some packages can fail to compile. 2100 # When users have crazy classpaths some packages can fail to compile.
1861 # and everything should work with empty CLASSPATH. 2101 # and everything should work with empty CLASSPATH.
1862 # This also helps prevent unexpected dependencies on random things 2102 # This also helps prevent unexpected dependencies on random things
1863 # from the CLASSPATH. 2103 # from the CLASSPATH.
1864 unset CLASSPATH 2104 export CLASSPATH=
1865 2105
1866 # Unset external ANT_ stuff 2106 # Unset external ANT_ stuff
1867 unset ANT_TASKS 2107 export ANT_TASKS=
1868 unset ANT_OPTS 2108 export ANT_OPTS=
1869} 2109}
1870 2110
1871# ------------------------------------------------------------------------------ 2111# ------------------------------------------------------------------------------
1872# @function-internal java-pkg-init-compiler_ 2112# @function-internal java-pkg-init-compiler_
1873# 2113#
1964 done 2204 done
1965 2205
1966 # If it hasn't been defined already, default to javac 2206 # If it hasn't been defined already, default to javac
1967 if [[ -z ${GENTOO_COMPILER} ]]; then 2207 if [[ -z ${GENTOO_COMPILER} ]]; then
1968 if [[ -n ${compilers} ]]; then 2208 if [[ -n ${compilers} ]]; then
1969 einfo "No suitable compiler found: defaulting javac for compilation" 2209 einfo "No suitable compiler found: defaulting to JDK default for compilation"
1970 else 2210 else
1971 # probably don't need to notify users about the default. 2211 # probably don't need to notify users about the default.
1972 :;#einfo "Defaulting to javac for compilation" 2212 :;#einfo "Defaulting to javac for compilation"
1973 fi 2213 fi
2214 if java-config -g GENTOO_COMPILER 2> /dev/null; then
2215 export GENTOO_COMPILER=$(java-config -g GENTOO_COMPILER)
2216 else
1974 export GENTOO_COMPILER=javac 2217 export GENTOO_COMPILER=javac
2218 fi
1975 else 2219 else
1976 einfo "Using ${GENTOO_COMPILER} for compilation" 2220 einfo "Using ${GENTOO_COMPILER} for compilation"
1977 fi 2221 fi
1978 2222
1979} 2223}
1995 fi 2239 fi
1996 2240
1997 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}" 2241 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
1998 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/" 2242 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
1999 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env" 2243 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2244 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2245 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2000 2246
2001 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib" 2247 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2002 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}" 2248 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2003 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps" 2249 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2004 2250
2017# Writes the package.env out to disk. 2263# Writes the package.env out to disk.
2018# 2264#
2019# ------------------------------------------------------------------------------ 2265# ------------------------------------------------------------------------------
2020# TODO change to do-write, to match everything else 2266# TODO change to do-write, to match everything else
2021java-pkg_do_write_() { 2267java-pkg_do_write_() {
2268 debug-print-function ${FUNCNAME} $*
2022 java-pkg_init_paths_ 2269 java-pkg_init_paths_
2023 # Create directory for package.env 2270 # Create directory for package.env
2024 dodir "${JAVA_PKG_SHAREPATH}" 2271 dodir "${JAVA_PKG_SHAREPATH}"
2025 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f "${JAVA_PKG_DEPEND}" ]]; then 2272 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2273 "${JAVA_PKG_DEPEND_FILE}" || -f \
2274 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2026 # Create package.env 2275 # Create package.env
2027 ( 2276 (
2028 echo "DESCRIPTION=\"${DESCRIPTION}\"" 2277 echo "DESCRIPTION=\"${DESCRIPTION}\""
2029 echo "GENERATION=\"2\"" 2278 echo "GENERATION=\"2\""
2279 echo "SLOT=\"${SLOT}\""
2030 2280
2031 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\"" 2281 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2032 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\"" 2282 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2033 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\"" 2283 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2034 [[ -f "${JAVA_PKG_DEPEND}" ]] && echo "DEPEND=\"$(cat ${JAVA_PKG_DEPEND} | uniq | tr '\n' ':')\"" 2284 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2285 && echo "DEPEND=\"$(cat "${JAVA_PKG_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2286 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2287 && echo "OPTIONAL_DEPEND=\"$(cat "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | uniq | tr '\n' ':')\""
2035 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup ! 2288 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2036 ) > "${JAVA_PKG_ENV}" 2289 ) > "${JAVA_PKG_ENV}"
2037 2290
2038 # register target/source 2291 # register target/source
2039 local target="$(java-pkg_get-target)" 2292 local target="$(java-pkg_get-target)"
2050 2303
2051 2304
2052 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}" 2305 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2053 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}" 2306 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2054 2307
2308 # extra env variables
2309 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2310 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2311 # nested echo to remove leading/trailing spaces
2312 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2313 >> "${JAVA_PKG_ENV}" || die
2314 fi
2315
2055 # Strip unnecessary leading and trailing colons 2316 # Strip unnecessary leading and trailing colons
2056 # TODO try to cleanup if possible 2317 # TODO try to cleanup if possible
2057 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?" 2318 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2319 else
2320 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2321 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2322 debug-print "write package.env."
2058 fi 2323 fi
2059} 2324}
2060 2325
2061# ------------------------------------------------------------------------------ 2326# ------------------------------------------------------------------------------
2062# @internal-function java-pkg_record-jar_ 2327# @internal-function java-pkg_record-jar_
2063# 2328#
2064# Record a dependency to the package.env 2329# Record an (optional) dependency to the package.env
2065# 2330# @param --optional - record dependency as optional
2331# @param $1 - package to record
2332# @param $2 - (optional) jar of package to record
2066# ------------------------------------------------------------------------------ 2333# ------------------------------------------------------------------------------
2067JAVA_PKG_DEPEND="${T}/java-pkg-depend" 2334JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2335JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2068 2336
2069java-pkg_record-jar_() { 2337java-pkg_record-jar_() {
2070 debug-print-function ${FUNCNAME} $* 2338 debug-print-function ${FUNCNAME} $*
2339
2340 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2341 if [[ "${1}" == "--optional" ]]; then
2342 depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"
2343 shift
2344 fi
2071 2345
2072 local pkg=${1} jar=${2} append 2346 local pkg=${1} jar=${2} append
2073 if [[ -z "${jar}" ]]; then 2347 if [[ -z "${jar}" ]]; then
2074 append="${pkg}" 2348 append="${pkg}"
2075 else 2349 else
2076 append="$(basename ${jar})@${pkg}" 2350 append="$(basename ${jar})@${pkg}"
2077 fi 2351 fi
2078 2352
2079 echo ${append} >> ${JAVA_PKG_DEPEND} 2353 echo "${append}" >> "${depend_file}"
2080} 2354}
2081 2355
2082# ------------------------------------------------------------------------------ 2356# ------------------------------------------------------------------------------
2083# @internal-function java-pkg_append_ 2357# @internal-function java-pkg_append_
2084# 2358#
2144# 2418#
2145# ------------------------------------------------------------------------------ 2419# ------------------------------------------------------------------------------
2146java-pkg_setup-vm() { 2420java-pkg_setup-vm() {
2147 debug-print-function ${FUNCNAME} $* 2421 debug-print-function ${FUNCNAME} $*
2148 2422
2423 export LANG="C" LC_ALL="C"
2424
2149 local vendor="$(java-pkg_get-vm-vendor)" 2425 local vendor="$(java-pkg_get-vm-vendor)"
2150 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then 2426 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2151 addpredict "/dev/random" 2427 addpredict "/dev/random"
2152 elif [[ "${vendor}" == "ibm" ]]; then 2428 elif [[ "${vendor}" == "ibm" ]]; then
2153 addpredict "/proc/self/maps" 2429 addpredict "/proc/self/maps"
2154 addpredict "/proc/cpuinfo" 2430 addpredict "/proc/cpuinfo"
2155 export LANG="C" LC_ALL="C"
2156 elif [[ "${vendor}" == "jrockit" ]]; then 2431 elif [[ "${vendor}" == "jrockit" ]]; then
2157 addpredict "/proc/cpuinfo" 2432 addpredict "/proc/cpuinfo"
2158 fi 2433 fi
2159} 2434}
2160 2435
2264 2539
2265 #TODO If you know a better solution let us know. 2540 #TODO If you know a better solution let us know.
2266 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)" 2541 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2267 2542
2268 local tann="${T}/announced-vm" 2543 local tann="${T}/announced-vm"
2544 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2545 # if people have for example modified eclasses some where
2269 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then 2546 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2270 # Add a check for setup/preinst phase... to avoid duplicate outputs
2271 # for when FEATURES=buildpkg
2272 if [[ ${EBUILD_PHASE} != "setup" && ${EBUILD_PHASE} != "preinst" && ${EBUILD_PHASE} != "postinst" ]];
2273 then
2274 einfo "Using: $(java-config -f)" 2547 einfo "Using: $(java-config -f)"
2275 [[ ! -f "${tann}" ]] && touch "${tann}" 2548 [[ ! -f "${tann}" ]] && touch "${tann}"
2276 fi
2277 fi 2549 fi
2278 2550
2279 else 2551 else
2280 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!" 2552 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2281 fi 2553 fi
2320# not. 2592# not.
2321# @param $1 (optional) - the file to check, otherwise checks whole ${D} 2593# @param $1 (optional) - the file to check, otherwise checks whole ${D}
2322# ------------------------------------------------------------------------------ 2594# ------------------------------------------------------------------------------
2323java-pkg_verify-classes() { 2595java-pkg_verify-classes() {
2324 #$(find ${D} -type f -name '*.jar' -o -name '*.class') 2596 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
2597
2598 local version_verify="/usr/bin/class-version-verify.py"
2599
2600 if [[ ! -x "${version_verify}" ]]; then
2601 version_verify="/usr/$(get_libdir)/javatoolkit/bin/class-version-verify.py"
2602 fi
2603
2604 if [[ ! -x "${version_verify}" ]]; then
2605 ewarn "Unable to perform class version checks as"
2606 ewarn "class-version-verify.py is unavailable"
2607 ewarn "Please install dev-java/javatoolkit."
2608 return
2609 fi
2610
2325 local target=$(java-pkg_get-target) 2611 local target=$(java-pkg_get-target)
2326 local result 2612 local result
2327 local log="${T}/class-version-verify.log" 2613 local log="${T}/class-version-verify.log"
2328 if [[ -n "${1}" ]]; then 2614 if [[ -n "${1}" ]]; then
2329 class-version-verify.py -v -t ${target} "${1}" > "${log}" 2615 ${version_verify} -v -t ${target} "${1}" > "${log}"
2330 result=$? 2616 result=$?
2331 else 2617 else
2332 ebegin "Verifying java class versions (target: ${target})" 2618 ebegin "Verifying java class versions (target: ${target})"
2333 class-version-verify.py -v -t ${target} -r "${D}" > "${log}" 2619 ${version_verify} -v -t ${target} -r "${D}" > "${log}"
2334 result=$? 2620 result=$?
2335 eend ${result} 2621 eend ${result}
2336 fi 2622 fi
2337 [[ -n ${JAVA_PKG_DEBUG} ]] && cat "${log}" 2623 [[ -n ${JAVA_PKG_DEBUG} ]] && cat "${log}"
2338 if [[ ${result} != 0 ]]; then 2624 if [[ ${result} != 0 ]]; then
2345 2631
2346# ---------------------------------------------------------------------------- 2632# ----------------------------------------------------------------------------
2347# @internal-function java-pkg_ensure-dep 2633# @internal-function java-pkg_ensure-dep
2348# Check that a package being used in jarfrom, getjars and getjar is contained 2634# Check that a package being used in jarfrom, getjars and getjar is contained
2349# within DEPEND or RDEPEND. 2635# within DEPEND or RDEPEND.
2350# @param $1 - Is the package a runtime dependency 2636# @param $1 - empty - check both vars; "runtime" or "build" - check only
2637# RDEPEND, resp. DEPEND
2351# @param $2 - Package name and slot. 2638# @param $2 - Package name and slot.
2352 2639
2353java-pkg_ensure-dep() { 2640java-pkg_ensure-dep() {
2354 debug-print-function ${FUNCNAME} $* 2641 debug-print-function ${FUNCNAME} $*
2355 2642
2356 local build_only="${1}" 2643 local limit_to="${1}"
2357 local target_pkg="${2}" 2644 local target_pkg="${2}"
2358 local dev_error="" 2645 local dev_error=""
2359 2646
2360 local stripped_pkg=$(echo "${target_pkg}" | sed \ 2647 local stripped_pkg=$(echo "${target_pkg}" | sed \
2361 's/-[0-9]*\(\.[0-9]\)*$//') 2648 's/-[0-9]*\(\.[0-9]\)*$//')
2362 2649
2650 debug-print "Matching against: ${stripped_pkg}"
2651
2363 if [[ ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then 2652 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ "$stripped_pkg" ) ]]; then
2364 dev_error="The ebuild is attempting to use ${target_pkg} that is not" 2653 dev_error="The ebuild is attempting to use ${target_pkg} that is not"
2365 dev_error="${dev_error} declared in DEPEND." 2654 dev_error="${dev_error} declared in DEPEND."
2366 if is-java-strict; then 2655 if is-java-strict; then
2656 eerror "${dev_error}"
2367 die "${dev_error}" 2657 die "${dev_error}"
2368 else 2658 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2369 eerror "${dev_error}" 2659 eerror "${dev_error}"
2370 einfo "Because you have this package installed the package will" 2660 elog "Because you have this package installed the package will"
2371 einfo "build without problems, but please report this to" 2661 elog "build without problems, but please report this to"
2372 einfo "http://bugs.gentoo.org" 2662 elog "http://bugs.gentoo.org"
2373 fi
2374 fi 2663 fi
2664 fi
2375 2665
2666 if [[ ${limit_to} != build ]]; then
2376 if [[ -z ${build_only} && ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then 2667 if [[ ! ( ${RDEPEND} =~ "${stripped_pkg}" ) ]]; then
2668 if [[ ! ( ${PDEPEND} =~ "${stripped_pkg}" ) ]]; then
2377 dev_error="The ebuild is attempting to use ${target_pkg}," 2669 dev_error="The ebuild is attempting to use ${target_pkg},"
2378 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND." 2670 dev_error="${dev_error} without specifying --build-only, that is not declared in RDEPEND"
2671 dev_error="${dev_error} or PDEPEND."
2379 if is-java-strict; then 2672 if is-java-strict; then
2380 die "${error}"
2381 else
2382 eerror "${dev_error}" 2673 eerror "${dev_error}"
2383 einfo "Because you have this package installed the package will" 2674 die "${dev_error}"
2384 einfo "build without problems, but please report this to" 2675 elif [[ ${BASH_SUBSHELL} = 0 ]]; then
2676 eerror "${dev_error}"
2677 elog "The package will build without problems, but may fail to run"
2678 elog "if you don't have ${target_pkg} installed, so please report"
2385 einfo "http://bugs.gentoo.org" 2679 elog "this to http://bugs.gentoo.org"
2680 fi
2681 fi
2386 fi 2682 fi
2387 fi 2683 fi
2388} 2684}
2389 2685
2390# ------------------------------------------------------------------------------ 2686# ------------------------------------------------------------------------------
2391# @section-end internal 2687# @section-end internal
2392# ------------------------------------------------------------------------------ 2688# ------------------------------------------------------------------------------
2393 2689
2394java-pkg_check-phase() { 2690java-pkg_check-phase() {
2395 local phase=${1} 2691 local phase=${1}
2396 local funcname=${2} 2692 local funcname=${FUNCNAME[1]}
2397 if is-java-strict && [[ ${EBUILD_PHASE} != ${phase} ]]; then 2693 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2398 java-pkg_announce-qa-violation \
2399 "${funcname} used outside of src_${phase}" 2694 local msg="${funcname} used outside of src_${phase}"
2695 java-pkg_announce-qa-violation "${msg}"
2400 fi 2696 fi
2401} 2697}
2402 2698
2403java-pkg_check-versioned-jar() { 2699java-pkg_check-versioned-jar() {
2404 local jar=${1} 2700 local jar=${1}
2413 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE" 2709 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2414 fi 2710 fi
2415} 2711}
2416 2712
2417java-pkg_announce-qa-violation() { 2713java-pkg_announce-qa-violation() {
2418 if is-java-strict; then 2714 local nodie
2715 if [[ ${1} == "--nodie" ]]; then
2716 nodie="true"
2717 shift
2718 fi
2419 echo "Java QA Notice: $@" >&2 2719 echo "Java QA Notice: $@" >&2
2420 increment-qa-violations 2720 increment-qa-violations
2421 fi 2721 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2422} 2722}
2423 2723
2424increment-qa-violations() { 2724increment-qa-violations() {
2425 let "JAVA_PKG_QA_VIOLATIONS+=1" 2725 let "JAVA_PKG_QA_VIOLATIONS+=1"
2426 export JAVA_PKG_QA_VIOLATIONS 2726 export JAVA_PKG_QA_VIOLATIONS
2429is-java-strict() { 2729is-java-strict() {
2430 [[ -n ${JAVA_PKG_STRICT} ]] 2730 [[ -n ${JAVA_PKG_STRICT} ]]
2431 return $? 2731 return $?
2432} 2732}
2433 2733
2734[[ "${EAPI}" = "2" ]] && EXPORT_FUNCTIONS src_prepare
2735
2434# ------------------------------------------------------------------------------ 2736# ------------------------------------------------------------------------------
2435# @eclass-end 2737# @eclass-end
2436# ------------------------------------------------------------------------------ 2738# ------------------------------------------------------------------------------

Legend:
Removed from v.1.70  
changed lines
  Added in v.1.113

  ViewVC Help
Powered by ViewVC 1.1.20