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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.167 - (show annotations) (download)
Thu Jul 30 22:17:08 2015 UTC (3 years, 6 months ago) by chewi
Branch: MAIN
Changes since 1.166: +3 -7 lines
Fix JAVA_RM_FILES by simplifying java-utils-2_src_prepare on the basis
that we won't be committing EAPI 0|1 ebuilds any more.

1 # Base eclass for Java packages
2 #
3 # Copyright (c) 2004-2005, Thomas Matthijs <axxo@gentoo.org>
4 # Copyright (c) 2004, Karl Trygve Kalleberg <karltk@gentoo.org>
5 # Copyright (c) 2004-2015, Gentoo Foundation
6 #
7 # Licensed under the GNU General Public License, v2
8 #
9 # $Header: /var/cvsroot/gentoo-x86/eclass/java-utils-2.eclass,v 1.166 2015/07/22 09:20:07 monsieurp Exp $
10
11 # @ECLASS: java-utils-2.eclass
12 # @MAINTAINER:
13 # java@gentoo.org
14 # @AUTHOR:
15 # Thomas Matthijs <axxo@gentoo.org>, Karl Trygve Kalleberg <karltk@gentoo.org>
16 # @BLURB: Base eclass for Java packages
17 # @DESCRIPTION:
18 # This eclass provides functionality which is used by java-pkg-2.eclass,
19 # java-pkg-opt-2.eclass and java-ant-2 eclass, as well as from ebuilds.
20 #
21 # This eclass should not be inherited this directly from an ebuild. Instead,
22 # you should inherit java-pkg-2 for Java packages or java-pkg-opt-2 for packages
23 # that have optional Java support. In addition you can inherit java-ant-2 for
24 # Ant-based packages.
25 inherit eutils versionator multilib
26
27 IUSE="elibc_FreeBSD"
28
29 # Make sure we use java-config-2
30 export WANT_JAVA_CONFIG="2"
31
32 # @VARIABLE: JAVA_PKG_PORTAGE_DEP
33 # @INTERNAL
34 # @DESCRIPTION:
35 # The version of portage we need to function properly. Previously it was
36 # portage with phase hooks support but now we use a version with proper env
37 # saving. For EAPI 2 we have new enough stuff so let's have cleaner deps.
38 has "${EAPI}" 0 1 && JAVA_PKG_PORTAGE_DEP=">=sys-apps/portage-2.1.2.7"
39
40 # @VARIABLE: JAVA_PKG_E_DEPEND
41 # @INTERNAL
42 # @DESCRIPTION:
43 # This is a convience variable to be used from the other java eclasses. This is
44 # the version of java-config we want to use. Usually the latest stable version
45 # so that ebuilds can use new features without depending on specific versions.
46 JAVA_PKG_E_DEPEND=">=dev-java/java-config-2.2.0 ${JAVA_PKG_PORTAGE_DEP}"
47 has source ${JAVA_PKG_IUSE} && JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} source? ( app-arch/zip )"
48
49 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BOOTCLASSPATH
50 # @DEFAULT_UNSET
51 # @DESCRIPTION:
52 # The version of bootclasspath the package needs to work. Translates to a proper
53 # dependency. The bootclasspath can then be obtained by java-ant_rewrite-bootclasspath
54 if [[ -n "${JAVA_PKG_WANT_BOOTCLASSPATH}" ]]; then
55 if [[ "${JAVA_PKG_WANT_BOOTCLASSPATH}" == "1.5" ]]; then
56 JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} >=dev-java/gnu-classpath-0.98-r1:0.98"
57 else
58 eerror "Unknown value of JAVA_PKG_WANT_BOOTCLASSPATH"
59 # since die in global scope doesn't work, this will make repoman fail
60 JAVA_PKG_E_DEPEND="${JAVA_PKG_E_DEPEND} BAD_JAVA_PKG_WANT_BOOTCLASSPATH"
61 fi
62 fi
63
64 # @ECLASS-VARIABLE: JAVA_PKG_ALLOW_VM_CHANGE
65 # @DESCRIPTION:
66 # Allow this eclass to change the active VM?
67 # If your system VM isn't sufficient for the package, the build will fail
68 # instead of trying to switch to another VM.
69 #
70 # Overriding the default can be useful for testing specific VMs locally, but
71 # should not be used in the final ebuild.
72 JAVA_PKG_ALLOW_VM_CHANGE=${JAVA_PKG_ALLOW_VM_CHANGE:="yes"}
73
74 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_VM
75 # @DEFAULT_UNSET
76 # @DESCRIPTION:
77 # Explicitly set a particular VM to use. If its not valid, it'll fall back to
78 # whatever /etc/java-config-2/build/jdk.conf would elect to use.
79 #
80 # Should only be used for testing and debugging.
81 #
82 # Example: use sun-jdk-1.5 to emerge foo:
83 # @CODE
84 # JAVA_PKG_FORCE_VM=sun-jdk-1.5 emerge foo
85 # @CODE
86
87 # @ECLASS-VARIABLE: JAVA_PKG_WANT_BUILD_VM
88 # @DEFAULT_UNSET
89 # @DESCRIPTION:
90 # A list of VM handles to choose a build VM from. If the list contains the
91 # currently active VM use that one, otherwise step through the list till a
92 # usable/installed VM is found.
93 #
94 # This allows to use an explicit list of JDKs in DEPEND instead of a virtual.
95 # Users of this variable must make sure at least one of the listed handles is
96 # covered by DEPEND.
97 # Requires JAVA_PKG_WANT_SOURCE and JAVA_PKG_WANT_TARGET to be set as well.
98
99 # @ECLASS-VARIABLE: JAVA_PKG_WANT_SOURCE
100 # @DEFAULT_UNSET
101 # @DESCRIPTION:
102 # Specify a non-standard Java source version for compilation (via javac -source
103 # parameter or Ant equivalent via build.xml rewriting done by java-ant-2 eclass).
104 # Normally this is determined from the jdk version specified in DEPEND.
105 # See java-pkg_get-source function below.
106 #
107 # Should generally only be used for testing and debugging.
108 #
109 # Use 1.4 source to emerge baz
110 # @CODE
111 # JAVA_PKG_WANT_SOURCE=1.4 emerge baz
112 # @CODE
113
114 # @ECLASS-VARIABLE: JAVA_PKG_WANT_TARGET
115 # @DEFAULT_UNSET
116 # @DESCRIPTION:
117 # Same as JAVA_PKG_WANT_SOURCE (see above) but for javac -target parameter,
118 # which affects the version of generated bytecode.
119 # Normally this is determined from the jre/jdk version specified in RDEPEND.
120 # See java-pkg_get-target function below.
121 #
122 # Should generallyonly be used for testing and debugging.
123 #
124 # emerge bar to be compatible with 1.3
125 # @CODE
126 # JAVA_PKG_WANT_TARGET=1.3 emerge bar
127 # @CODE
128
129 # @VARIABLE: JAVA_PKG_COMPILER_DIR
130 # @INTERNAL
131 # @DESCRIPTION:
132 # Directory where compiler settings are saved, without trailing slash.
133 # You probably shouldn't touch this variable except local testing.
134 JAVA_PKG_COMPILER_DIR=${JAVA_PKG_COMPILER_DIR:="/usr/share/java-config-2/compiler"}
135
136 # @VARIABLE: JAVA_PKG_COMPILERS_CONF
137 # @INTERNAL
138 # @DESCRIPTION:
139 # Path to file containing information about which compiler to use.
140 # Can be overloaded, but it should be overloaded only for local testing.
141 JAVA_PKG_COMPILERS_CONF=${JAVA_PKG_COMPILERS_CONF:="/etc/java-config-2/build/compilers.conf"}
142
143 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_COMPILER
144 # @INTERNAL
145 # @DEFAULT_UNSET
146 # @DESCRIPTION:
147 # Explicitly set a list of compilers to choose from. This is normally read from
148 # JAVA_PKG_COMPILERS_CONF.
149 #
150 # Useful for local testing.
151 #
152 # Use jikes and javac, in that order
153 # @CODE
154 # JAVA_PKG_FORCE_COMPILER="jikes javac"
155 # @CODE
156
157 # @ECLASS-VARIABLE: JAVA_PKG_FORCE_ANT_TASKS
158 # @DEFAULT_UNSET
159 # @DESCRIPTION:
160 # An $IFS separated list of ant tasks. Can be set in environment before calling
161 # emerge/ebuild to override variables set in ebuild, mainly for testing before
162 # putting the resulting (WANT_)ANT_TASKS into ebuild. Affects only ANT_TASKS in
163 # eant() call, not the dependencies specified in WANT_ANT_TASKS.
164 #
165 # @CODE
166 # JAVA_PKG_FORCE_ANT_TASKS="ant-junit ant-trax" \
167 # ebuild foo.ebuild compile
168 # @CODE
169
170 # TODO document me
171 JAVA_PKG_QA_VIOLATIONS=0
172
173 # @FUNCTION: java-pkg_doexamples
174 # @USAGE: [--subdir <subdir>] <file1/dir1> [<file2> ...]
175 # @DESCRIPTION:
176 # Installs given arguments to /usr/share/doc/${PF}/examples
177 # If you give it only one parameter and it is a directory it will install
178 # everything in that directory to the examples directory.
179 #
180 # @CODE
181 # Parameters:
182 # --subdir - If the examples need a certain directory structure
183 # $* - list of files to install
184 #
185 # Examples:
186 # java-pkg_doexamples demo
187 # java-pkg_doexamples demo/* examples/*
188 # @CODE
189 java-pkg_doexamples() {
190 debug-print-function ${FUNCNAME} $*
191
192 [[ ${#} -lt 1 ]] && die "At least one argument needed"
193
194 java-pkg_check-phase install
195 java-pkg_init_paths_
196
197 local dest=/usr/share/doc/${PF}/examples
198 if [[ ${1} == --subdir ]]; then
199 local dest=${dest}/${2}
200 dodir ${dest}
201 shift 2
202 fi
203
204 if [[ ${#} = 1 && -d ${1} ]]; then
205 ( # dont want to pollute calling env
206 insinto "${dest}"
207 doins -r ${1}/*
208 ) || die "Installing examples failed"
209 else
210 ( # dont want to pollute calling env
211 insinto "${dest}"
212 doins -r "$@"
213 ) || die "Installing examples failed"
214 fi
215
216 # Let's make a symlink to the directory we have everything else under
217 dosym "${dest}" "${JAVA_PKG_SHAREPATH}/examples" || die
218 }
219
220 # @FUNCTION: java-pkg_addres
221 # @USAGE: <jar> <dir> [<find arguments> ...]
222 # @DESCRIPTION:
223 # Adds resource files to an existing jar.
224 # It is important that the directory given is actually the root of the
225 # corresponding resource tree. The target directory as well as
226 # sources.lst, MANIFEST.MF, *.class, *.jar, and *.java files are
227 # automatically excluded. Symlinks are always followed. Additional
228 # arguments are passed through to find.
229 #
230 # @CODE
231 # java-pkg_addres ${PN}.jar resources ! -name "*.html"
232 # @CODE
233 #
234 # @param $1 - jar file
235 # @param $2 - resource tree directory
236 # @param $* - arguments to pass to find
237 java-pkg_addres() {
238 debug-print-function ${FUNCNAME} $*
239
240 [[ ${#} -lt 2 ]] && die "at least two arguments needed"
241
242 local jar=$(realpath "$1" || die "realpath $1 failed")
243 local dir="$2"
244 shift 2
245
246 pushd "${dir}" > /dev/null || die "pushd ${dir} failed"
247 find -L -type f ! -path "./target/*" ! -path "./sources.lst" ! -name "MANIFEST.MF" ! -regex ".*\.\(class\|jar\|java\)" "${@}" -print0 | xargs -0 jar uf "${jar}" || die "jar failed"
248 popd > /dev/null || die "popd failed"
249 }
250
251 # @FUNCTION: java-pkg_rm_files
252 # @USAGE: java-pkg_rm_files File1.java File2.java ...
253 # @DESCRIPTION:
254 # Remove unneeded files in ${S}.
255 #
256 # Every now and then, you'll run into situations whereby a file needs removing,
257 # be it a unit test or a regular java class.
258 #
259 # You can use this function by either:
260 # - calling it yourself in java_prepare() and feeding java-pkg_rm_files with
261 # the list of files you wish to remove.
262 # - defining an array in the ebuild named JAVA_RM_FILES with the list of files
263 # you wish to remove.
264 #
265 # Both way work and it is left to the developer's preferences. If the
266 # JAVA_RM_FILES array is defined, it is will be automatically handed over to
267 # java-pkg_rm_files.
268 #
269 # See java-utils-2_src_prepare.
270 #
271 # @CODE
272 #
273 # @param $* - list of files to remove.
274 # JAVA_RM_FILES - array containing files to remove.
275 # if defined, automatically handed over to java-pkg_rm_files in java-utils-2_src_prepare.
276 #
277 # @CODE
278 java-pkg_rm_files() {
279 debug-print-function ${FUNCNAME} $*
280 OIFS="$IFS"
281 IFS="\n"
282 for filename in "$@"; do
283 [[ ! -f "${filename}" ]] && die "${filename} is not a regular file. Aborting."
284 einfo "Removing unneeded file ${filename}"
285 rm -f "${S}/${filename}" || die "cannot remove ${filename}"
286 eend $?
287 done
288 IFS="$OIFS"
289 }
290
291 # @FUNCTION: java-pkg_dojar
292 # @USAGE: <jar1> [<jar2> ...]
293 # @DESCRIPTION:
294 # Installs any number of jars.
295 # Jar's will be installed into /usr/share/${PN}(-${SLOT})/lib/ by default.
296 # You can use java-pkg_jarinto to change this path.
297 # You should never install a jar with a package version in the filename.
298 # Instead, use java-pkg_newjar defined below.
299 #
300 # @CODE
301 # java-pkg_dojar dist/${PN}.jar dist/${PN}-core.jar
302 # @CODE
303 #
304 # @param $* - list of jars to install
305 java-pkg_dojar() {
306 debug-print-function ${FUNCNAME} $*
307
308 [[ ${#} -lt 1 ]] && die "At least one argument needed"
309
310 java-pkg_check-phase install
311 java-pkg_init_paths_
312
313 # Create JARDEST if it doesn't exist
314 dodir ${JAVA_PKG_JARDEST}
315
316 local jar
317 # for each jar
318 for jar in "${@}"; do
319 local jar_basename=$(basename "${jar}")
320
321 java-pkg_check-versioned-jar ${jar_basename}
322
323 # check if it exists
324 if [[ -e "${jar}" ]] ; then
325 # Don't overwrite if jar has already been installed with the same
326 # name
327 local dest="${D}${JAVA_PKG_JARDEST}/${jar_basename}"
328 if [[ -e "${dest}" ]]; then
329 ewarn "Overwriting ${dest}"
330 fi
331
332 # install it into JARDEST if it's a non-symlink
333 if [[ ! -L "${jar}" ]] ; then
334 #but first check class version when in strict mode.
335 is-java-strict && java-pkg_verify-classes "${jar}"
336
337 INSDESTTREE="${JAVA_PKG_JARDEST}" \
338 doins "${jar}" || die "failed to install ${jar}"
339 java-pkg_append_ JAVA_PKG_CLASSPATH "${JAVA_PKG_JARDEST}/${jar_basename}"
340 debug-print "installed ${jar} to ${D}${JAVA_PKG_JARDEST}"
341 # make a symlink to the original jar if it's symlink
342 else
343 # TODO use dosym, once we find something that could use it
344 # -nichoj
345 ln -s "$(readlink "${jar}")" "${D}${JAVA_PKG_JARDEST}/${jar_basename}"
346 debug-print "${jar} is a symlink, linking accordingly"
347 fi
348 else
349 die "${jar} does not exist"
350 fi
351 done
352
353 java-pkg_do_write_
354 }
355
356 # @FUNCTION: java-pkg_regjar
357 # @USAGE: </path/to/installed/jar>
358 # @DESCRIPTION:
359 # Records an already installed (in ${D}) jar in the package.env
360 # This would mostly be used if the package has make or a custom script to
361 # install things.
362 #
363 # WARNING:
364 # if you want to use shell expansion, you have to use ${D}/... as the for in
365 # this function will not be able to expand the path, here's an example:
366 #
367 # @CODE
368 # java-pkg_regjar ${D}/opt/my-java/lib/*.jar
369 # @CODE
370 #
371
372 # TODO should we be making sure the jar is present on ${D} or wherever?
373 java-pkg_regjar() {
374 debug-print-function ${FUNCNAME} $*
375
376 java-pkg_check-phase install
377
378 [[ ${#} -lt 1 ]] && die "at least one argument needed"
379
380 java-pkg_init_paths_
381
382 local jar jar_dir jar_file
383 for jar in "${@}"; do
384 # TODO use java-pkg_check-versioned-jar
385 if [[ -e "${jar}" || -e "${D}${jar}" ]]; then
386 [[ -d "${jar}" || -d "${D}${jar}" ]] \
387 && die "Called ${FUNCNAME} on a directory $*"
388
389 #check that class version correct when in strict mode
390 is-java-strict && java-pkg_verify-classes "${jar}"
391
392 # nelchael: we should strip ${D} in this case too, here's why:
393 # imagine such call:
394 # java-pkg_regjar ${D}/opt/java/*.jar
395 # such call will fall into this case (-e ${jar}) and will
396 # record paths with ${D} in package.env
397 java-pkg_append_ JAVA_PKG_CLASSPATH "${jar#${D}}"
398 else
399 if [[ ${jar} = *\** ]]; then
400 eerror "The argument ${jar} to ${FUNCNAME}"
401 eerror "has * in it. If you want it to glob in"
402 eerror '${D} add ${D} to the argument.'
403 fi
404 debug-print "${jar} or ${D}${jar} not found"
405 die "${jar} does not exist"
406 fi
407 done
408
409 java-pkg_do_write_
410 }
411
412 # @FUNCTION: java-pkg_newjar
413 # @USAGE: <path/to/oldname.jar> [<newname.jar>]
414 # @DESCRIPTION:
415 # Installs a jar with a new name (defaults to $PN.jar)
416 #
417 # For example, installs a versioned jar without the version
418 java-pkg_newjar() {
419 debug-print-function ${FUNCNAME} $*
420
421 local original_jar="${1}"
422 local new_jar="${2:-${PN}.jar}"
423 local new_jar_dest="${T}/${new_jar}"
424
425 [[ -z ${original_jar} ]] && die "Must specify a jar to install"
426 [[ ! -f ${original_jar} ]] \
427 && die "${original_jar} does not exist or is not a file!"
428
429 rm -f "${new_jar_dest}" || die "Failed to remove ${new_jar_dest}"
430 cp "${original_jar}" "${new_jar_dest}" \
431 || die "Failed to copy ${original_jar} to ${new_jar_dest}"
432 java-pkg_dojar "${new_jar_dest}"
433 }
434
435 # @FUNCTION: java-pkg_addcp
436 # @USAGE: <classpath>
437 # @DESCRIPTION:
438 # Add something to the package's classpath. For jars, you should use dojar,
439 # newjar, or regjar. This is typically used to add directories to the classpath.
440 # The parameters of this function are appended to JAVA_PKG_CLASSPATH
441 java-pkg_addcp() {
442 java-pkg_append_ JAVA_PKG_CLASSPATH "${@}"
443 java-pkg_do_write_
444 }
445
446 # @FUNCTION: java-pkg_doso
447 # @USAGE: <path/to/file1.so> [...]
448 # @DESCRIPTION:
449 # Installs any number of JNI libraries
450 # They will be installed into /usr/lib by default, but java-pkg_sointo
451 # can be used change this path
452 #
453 # @CODE
454 # Example:
455 # java-pkg_doso *.so
456 # @CODE
457 java-pkg_doso() {
458 debug-print-function ${FUNCNAME} $*
459
460 java-pkg_check-phase install
461
462 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
463
464 java-pkg_init_paths_
465
466 local lib
467 # for each lib
468 for lib in "$@" ; do
469 # if the lib exists...
470 if [[ -e "${lib}" ]] ; then
471 # install if it isn't a symlink
472 if [[ ! -L "${lib}" ]] ; then
473 INSDESTTREE="${JAVA_PKG_LIBDEST}" \
474 INSOPTIONS="-m0755" \
475 doins "${lib}" || die "failed to install ${lib}"
476 java-pkg_append_ JAVA_PKG_LIBRARY "${JAVA_PKG_LIBDEST}"
477 debug-print "Installing ${lib} to ${JAVA_PKG_LIBDEST}"
478 # otherwise make a symlink to the symlink's origin
479 else
480 dosym "$(readlink "${lib}")" "${JAVA_PKG_LIBDEST}/${lib##*/}"
481 debug-print "${lib} is a symlink, linking accordantly"
482 fi
483 # otherwise die
484 else
485 die "${lib} does not exist"
486 fi
487 done
488
489 java-pkg_do_write_
490 }
491
492 # @FUNCTION: java-pkg_regso
493 # @USAGE: <file1.so> [...]
494 # @DESCRIPTION:
495 # Registers an already installed JNI library in package.env.
496 #
497 # @CODE
498 # Parameters:
499 # $@ - JNI libraries to register
500 #
501 # Example:
502 # java-pkg_regso *.so /path/*.so
503 # @CODE
504 java-pkg_regso() {
505 debug-print-function ${FUNCNAME} $*
506
507 java-pkg_check-phase install
508
509 [[ ${#} -lt 1 ]] && die "${FUNCNAME} requires at least one argument"
510
511 java-pkg_init_paths_
512
513 local lib target_dir
514 for lib in "$@" ; do
515 # Check the absolute path of the lib
516 if [[ -e "${lib}" ]] ; then
517 target_dir="$(java-pkg_expand_dir_ ${lib})"
518 java-pkg_append_ JAVA_PKG_LIBRARY "/${target_dir#${D}}"
519 # Check the path of the lib relative to ${D}
520 elif [[ -e "${D}${lib}" ]]; then
521 target_dir="$(java-pkg_expand_dir_ ${D}${lib})"
522 java-pkg_append_ JAVA_PKG_LIBRARY "${target_dir}"
523 else
524 die "${lib} does not exist"
525 fi
526 done
527
528 java-pkg_do_write_
529 }
530
531 # @FUNCTION: java-pkg_jarinto
532 # @USAGE: </path/to/install/jars/into>
533 # @DESCRIPTION:
534 # Changes the path jars are installed into via subsequent java-pkg_dojar calls.
535 java-pkg_jarinto() {
536 debug-print-function ${FUNCNAME} $*
537
538 JAVA_PKG_JARDEST="${1}"
539 }
540
541 # @FUNCTION: java-pkg_sointo
542 # @USAGE: </path/to/install/sofiles/into>
543 # @DESCRIPTION:
544 # Changes the path that JNI libraries are installed into via subsequent
545 # java-pkg_doso calls.
546 java-pkg_sointo() {
547 debug-print-function ${FUNCNAME} $*
548
549 JAVA_PKG_LIBDEST="${1}"
550 }
551
552 # @FUNCTION: java-pkg_dohtml
553 # @USAGE: <path/to/javadoc/documentation> [...]
554 # @DESCRIPTION:
555 # Install Javadoc HTML documentation. Usage of java-pkg_dojavadoc is preferred.
556 #
557 # @CODE
558 # java-pkg_dohtml dist/docs/
559 # @CODE
560 java-pkg_dohtml() {
561 debug-print-function ${FUNCNAME} $*
562
563 [[ ${#} -lt 1 ]] && die "At least one argument required for ${FUNCNAME}"
564
565 # from /usr/lib/portage/bin/dohtml -h
566 # -f Set list of allowed extensionless file names.
567 dohtml -f package-list "$@"
568
569 # this probably shouldn't be here but it provides
570 # a reasonable way to catch # docs for all of the
571 # old ebuilds.
572 java-pkg_recordjavadoc
573 }
574
575 # @FUNCTION: java-pkg_dojavadoc
576 # @USAGE: [--symlink destination] <path/to/javadocs/root>
577 # @DESCRIPTION:
578 # Installs javadoc documentation. This should be controlled by the doc use flag.
579 #
580 # @CODE
581 # Parameters:
582 # $1: optional --symlink creates to symlink like this for html
583 # documentation bundles.
584 # $2: - The javadoc root directory.
585 #
586 # Examples:
587 # java-pkg_dojavadoc docs/api
588 # java-pkg_dojavadoc --symlink apidocs docs/api
589 # @CODE
590 java-pkg_dojavadoc() {
591 debug-print-function ${FUNCNAME} $*
592
593 # For html documentation bundles that link to Javadoc
594 local symlink
595 if [[ ${1} = --symlink ]]; then
596 symlink=${2}
597 shift 2
598 fi
599
600 local dir="$1"
601 local dest=/usr/share/doc/${PF}/html
602
603 # QA checks
604
605 java-pkg_check-phase install
606 java-pkg_init_paths_
607
608 [[ -z "${dir}" ]] && die "Must specify a directory!"
609 [[ ! -d "${dir}" ]] && die "${dir} does not exist, or isn't a directory!"
610 if [[ ! -e "${dir}/index.html" ]]; then
611 local msg="No index.html in javadoc directory"
612 ewarn "${msg}"
613 is-java-strict && die "${msg}"
614 fi
615
616 if [[ -e ${D}/${dest}/api ]]; then
617 eerror "${dest} already exists. Will not overwrite."
618 die "${dest}"
619 fi
620
621 # Renaming to match our directory layout
622
623 local dir_to_install="${dir}"
624 if [[ "$(basename "${dir}")" != "api" ]]; then
625 dir_to_install="${T}/api"
626 # TODO use doins
627 cp -r "${dir}" "${dir_to_install}" || die "cp failed"
628 fi
629
630 # Actual installation
631
632 java-pkg_dohtml -r "${dir_to_install}"
633
634 # Let's make a symlink to the directory we have everything else under
635 dosym ${dest}/api "${JAVA_PKG_SHAREPATH}/api" || die
636
637 if [[ ${symlink} ]]; then
638 debug-print "symlinking ${dest}/{api,${symlink}}"
639 dosym ${dest}/{api,${symlink}} || die
640 fi
641 }
642
643 # @FUNCTION: java-pkg_dosrc
644 # @USAGE: <path/to/sources> [...]
645 # @DESCRIPTION:
646 # Installs a zip containing the source for a package, so it can used in
647 # from IDEs like eclipse and netbeans.
648 # Ebuild needs to DEPEND on app-arch/zip to use this. It also should be controlled by USE=source.
649 #
650 # @CODE
651 # Example:
652 # java-pkg_dosrc src/*
653 # @CODE
654
655 # TODO change so it the arguments it takes are the base directories containing
656 # source -nichoj
657 #
658 # TODO should we be able to handle multiple calls to dosrc? -nichoj
659 #
660 # TODO maybe we can take an existing zip/jar? -nichoj
661 #
662 # FIXME apparently this fails if you give it an empty directories
663 java-pkg_dosrc() {
664 debug-print-function ${FUNCNAME} $*
665
666 [ ${#} -lt 1 ] && die "At least one argument needed"
667
668 java-pkg_check-phase install
669
670 [[ ${#} -lt 1 ]] && die "At least one argument needed"
671
672 if ! [[ ${DEPEND} = *app-arch/zip* ]]; then
673 local msg="${FUNCNAME} called without app-arch/zip in DEPEND"
674 java-pkg_announce-qa-violation ${msg}
675 fi
676
677 java-pkg_init_paths_
678
679 local zip_name="${PN}-src.zip"
680 local zip_path="${T}/${zip_name}"
681 local dir
682 for dir in "${@}"; do
683 local dir_parent=$(dirname "${dir}")
684 local dir_name=$(basename "${dir}")
685 pushd ${dir_parent} > /dev/null || die "problem entering ${dir_parent}"
686 zip -q -r ${zip_path} ${dir_name} -i '*.java'
687 local result=$?
688 # 12 means zip has nothing to do
689 if [[ ${result} != 12 && ${result} != 0 ]]; then
690 die "failed to zip ${dir_name}"
691 fi
692 popd >/dev/null
693 done
694
695 # Install the zip
696 INSDESTTREE=${JAVA_PKG_SOURCESPATH} \
697 doins ${zip_path} || die "Failed to install source"
698
699 JAVA_SOURCES="${JAVA_PKG_SOURCESPATH}/${zip_name}"
700 java-pkg_do_write_
701 }
702
703 # @FUNCTION: java-pkg_dolauncher
704 # @USAGE: <filename> [options]
705 # @DESCRIPTION:
706 # Make a wrapper script to lauch/start this package
707 # If necessary, the wrapper will switch to the appropriate VM.
708 #
709 # Can be called without parameters if the package installs only one jar
710 # that has the Main-class attribute set. The wrapper will be named ${PN}.
711 #
712 # @CODE
713 # Parameters:
714 # $1 - filename of launcher to create
715 # $2 - options, as follows:
716 # --main the.main.class.to.start
717 # --jar /the/jar/too/launch.jar or just <name>.jar
718 # --java_args 'Extra arguments to pass to java'
719 # --pkg_args 'Extra arguments to pass to the package'
720 # --pwd Directory the launcher changes to before executing java
721 # -into Directory to install the launcher to, instead of /usr/bin
722 # -pre Prepend contents of this file to the launcher
723 # @CODE
724 java-pkg_dolauncher() {
725 debug-print-function ${FUNCNAME} $*
726
727 java-pkg_check-phase install
728 java-pkg_init_paths_
729
730 if [[ ${#} = 0 ]]; then
731 local name="${PN}"
732 else
733 local name="${1}"
734 shift
735 fi
736
737 # TODO rename to launcher
738 local target="${T}/${name}"
739 local var_tmp="${T}/launcher_variables_tmp"
740 local target_dir pre
741
742 # Process the other the rest of the arguments
743 while [[ -n "${1}" && -n "${2}" ]]; do
744 local var="${1}" value="${2}"
745 if [[ "${var:0:2}" == "--" ]]; then
746 local var=${var:2}
747 echo "gjl_${var}=\"${value}\"" >> "${var_tmp}"
748 local gjl_${var}="${value}"
749 elif [[ "${var}" == "-into" ]]; then
750 target_dir="${value}"
751 elif [[ "${var}" == "-pre" ]]; then
752 pre="${value}"
753 fi
754 shift 2
755 done
756
757 # Test if no --jar and --main arguments were given and
758 # in that case check if the package only installs one jar
759 # and use that jar.
760 if [[ -z "${gjl_jar}" && -z "${gjl_main}" ]]; then
761 local cp="${JAVA_PKG_CLASSPATH}"
762 if [[ "${cp/:}" = "${cp}" && "${cp%.jar}" != "${cp}" ]]; then
763 echo "gjl_jar=\"${JAVA_PKG_CLASSPATH}\"" >> "${var_tmp}"
764 else
765 local msg="Not enough information to create a launcher given."
766 msg="${msg} Please give --jar or --main argument to ${FUNCNAME}."
767 die "${msg}"
768 fi
769 fi
770
771 # Write the actual script
772 echo "#!/bin/bash" > "${target}"
773 if [[ -n "${pre}" ]]; then
774 if [[ -f "${pre}" ]]; then
775 cat "${pre}" >> "${target}"
776 else
777 die "-pre specified file '${pre}' does not exist"
778 fi
779 fi
780 echo "gjl_package=${JAVA_PKG_NAME}" >> "${target}"
781 cat "${var_tmp}" >> "${target}"
782 rm -f "${var_tmp}"
783 echo "source /usr/share/java-config-2/launcher/launcher.bash" >> "${target}"
784
785 if [[ -n "${target_dir}" ]]; then
786 DESTTREE="${target_dir}" dobin "${target}"
787 local ret=$?
788 return ${ret}
789 else
790 dobin "${target}"
791 fi
792 }
793
794 # @FUNCTION: java-pkg_dowar
795 # @DESCRIPTION:
796 # Install war files.
797 # TODO document
798 java-pkg_dowar() {
799 debug-print-function ${FUNCNAME} $*
800
801 # Check for arguments
802 [[ ${#} -lt 1 ]] && die "At least one argument needed"
803 java-pkg_check-phase install
804
805 java-pkg_init_paths_
806
807 local war
808 for war in $* ; do
809 local warpath
810 # TODO evaluate if we want to handle symlinks differently -nichoj
811 # Check for symlink
812 if [[ -L "${war}" ]] ; then
813 cp "${war}" "${T}"
814 warpath="${T}$(basename "${war}")"
815 # Check for directory
816 # TODO evaluate if we want to handle directories differently -nichoj
817 elif [[ -d "${war}" ]] ; then
818 echo "dowar: warning, skipping directory ${war}"
819 continue
820 else
821 warpath="${war}"
822 fi
823
824 # Install those files like you mean it
825 INSOPTIONS="-m 0644" \
826 INSDESTTREE=${JAVA_PKG_WARDEST} \
827 doins ${warpath}
828 done
829 }
830
831 # @FUNCTION: java-pkg_recordjavadoc
832 # @INTERNAL
833 # @DESCRIPTION:
834 # Scan for JavaDocs, and record their existence in the package.env file
835
836 # TODO make sure this in the proper section
837 java-pkg_recordjavadoc()
838 {
839 debug-print-function ${FUNCNAME} $*
840 # the find statement is important
841 # as some packages include multiple trees of javadoc
842 JAVADOC_PATH="$(find ${D}/usr/share/doc/ -name allclasses-frame.html -printf '%h:')"
843 # remove $D - TODO: check this is ok with all cases of the above
844 JAVADOC_PATH="${JAVADOC_PATH//${D}}"
845 if [[ -n "${JAVADOC_PATH}" ]] ; then
846 debug-print "javadocs found in ${JAVADOC_PATH%:}"
847 java-pkg_do_write_
848 else
849 debug-print "No javadocs found"
850 fi
851 }
852
853
854 # @FUNCTION: java-pkg_jar-from
855 # @USAGE: [--build-only] [--with-dependencies] [--virtual] [--into dir] <package> [<package.jar>] [<destination.jar>]
856 # @DESCRIPTION:
857 # Makes a symlink to a jar from a certain package
858 # A lot of java packages include dependencies in a lib/ directory
859 # You can use this function to replace these bundled dependencies.
860 # The dependency is recorded into package.env DEPEND line, unless "--build-only"
861 # is passed as the very first argument, for jars that have to be present only
862 # at build time and are not needed on runtime (junit testing etc).
863 #
864 # @CODE
865 # Example: get all jars from xerces slot 2
866 # java-pkg_jar-from xerces-2
867 #
868 # Example: get a specific jar from xerces slot 2
869 # java-pkg_jar-from xerces-2 xml-apis.jar
870 #
871 # Example: get a specific jar from xerces slot 2, and name it diffrently
872 # java-pkg_jar-from xerces-2 xml-apis.jar xml.jar
873 #
874 # Example: get junit.jar which is needed only for building
875 # java-pkg_jar-from --build-only junit junit.jar
876 # @CODE
877 #
878 # @CODE
879 # Parameters
880 # --build-only - makes the jar(s) not added into package.env DEPEND line.
881 # (assumed automatically when called inside src_test)
882 # --with-dependencies - get jars also from requested package's dependencies
883 # transitively.
884 # --virtual - Packages passed to this function are to be handled as virtuals
885 # and will not have individual jar dependencies recorded.
886 # --into $dir - symlink jar(s) into $dir (must exist) instead of .
887 # $1 - Package to get jars from, or comma-separated list of packages in
888 # case other parameters are not used.
889 # $2 - jar from package. If not specified, all jars will be used.
890 # $3 - When a single jar is specified, destination filename of the
891 # symlink. Defaults to the name of the jar.
892 # @CODE
893
894 # TODO could probably be cleaned up a little
895 java-pkg_jar-from() {
896 debug-print-function ${FUNCNAME} $*
897
898 local build_only=""
899 local destdir="."
900 local deep=""
901 local virtual=""
902 local record_jar=""
903
904 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
905
906 while [[ "${1}" == --* ]]; do
907 if [[ "${1}" = "--build-only" ]]; then
908 build_only="build"
909 elif [[ "${1}" = "--with-dependencies" ]]; then
910 deep="--with-dependencies"
911 elif [[ "${1}" = "--virtual" ]]; then
912 virtual="true"
913 elif [[ "${1}" = "--into" ]]; then
914 destdir="${2}"
915 shift
916 else
917 die "java-pkg_jar-from called with unknown parameter: ${1}"
918 fi
919 shift
920 done
921
922 local target_pkg="${1}" target_jar="${2}" destjar="${3}"
923
924 [[ -z ${target_pkg} ]] && die "Must specify a package"
925
926 if [[ "${EAPI}" == "1" ]]; then
927 target_pkg="${target_pkg//:/-}"
928 fi
929
930 # default destjar to the target jar
931 [[ -z "${destjar}" ]] && destjar="${target_jar}"
932
933 local error_msg="There was a problem getting the classpath for ${target_pkg}."
934 local classpath
935 classpath="$(java-config ${deep} --classpath=${target_pkg})"
936 [[ $? != 0 ]] && die ${error_msg}
937
938 # When we have commas this functions is called to bring jars from multiple
939 # packages. This affects recording of dependencencies performed later
940 # which expects one package only, so we do it here.
941 if [[ ${target_pkg} = *,* ]]; then
942 for pkg in ${target_pkg//,/ }; do
943 java-pkg_ensure-dep "${build_only}" "${pkg}"
944 [[ -z "${build_only}" ]] && java-pkg_record-jar_ "${pkg}"
945 done
946 # setting this disables further record-jar_ calls later
947 record_jar="true"
948 else
949 java-pkg_ensure-dep "${build_only}" "${target_pkg}"
950 fi
951
952 # Record the entire virtual as a dependency so that
953 # no jars are missed.
954 if [[ -z "${build_only}" && -n "${virtual}" ]]; then
955 java-pkg_record-jar_ "${target_pkg}"
956 # setting this disables further record-jars_ calls later
957 record_jar="true"
958 fi
959
960 pushd ${destdir} > /dev/null \
961 || die "failed to change directory to ${destdir}"
962
963 local jar
964 for jar in ${classpath//:/ }; do
965 local jar_name=$(basename "${jar}")
966 if [[ ! -f "${jar}" ]] ; then
967 debug-print "${jar} from ${target_pkg} does not exist"
968 die "Installation problems with jars in ${target_pkg} - is it installed?"
969 fi
970 # If no specific target jar was indicated, link it
971 if [[ -z "${target_jar}" ]] ; then
972 [[ -f "${target_jar}" ]] && rm "${target_jar}"
973 ln -snf "${jar}" \
974 || die "Failed to make symlink from ${jar} to ${jar_name}"
975 if [[ -z "${record_jar}" ]]; then
976 if [[ -z "${build_only}" ]]; then
977 java-pkg_record-jar_ "${target_pkg}" "${jar}"
978 else
979 java-pkg_record-jar_ --build-only "${target_pkg}" "${jar}"
980 fi
981 fi
982 # otherwise, if the current jar is the target jar, link it
983 elif [[ "${jar_name}" == "${target_jar}" ]] ; then
984 [[ -f "${destjar}" ]] && rm "${destjar}"
985 ln -snf "${jar}" "${destjar}" \
986 || die "Failed to make symlink from ${jar} to ${destjar}"
987 if [[ -z "${record_jar}" ]]; then
988 if [[ -z "${build_only}" ]]; then
989 java-pkg_record-jar_ "${target_pkg}" "${jar}"
990 else
991 java-pkg_record-jar_ --build-only "${target_pkg}" "${jar}"
992 fi
993 fi
994 popd > /dev/null
995 return 0
996 fi
997 done
998 popd > /dev/null
999 # if no target was specified, we're ok
1000 if [[ -z "${target_jar}" ]] ; then
1001 return 0
1002 # otherwise, die bitterly
1003 else
1004 die "Failed to find ${target_jar:-jar} in ${target_pkg}"
1005 fi
1006 }
1007
1008 # @FUNCTION: java-pkg_jarfrom
1009 # @DESCRIPTION:
1010 # See java-pkg_jar-from
1011 java-pkg_jarfrom() {
1012 java-pkg_jar-from "$@"
1013 }
1014
1015 # @FUNCTION: java-pkg_getjars
1016 # @USAGE: [--build-only] [--with-dependencies] <package1>[,<package2>...]
1017 # @DESCRIPTION:
1018 # Get the classpath provided by any number of packages
1019 # Among other things, this can be passed to 'javac -classpath' or 'ant -lib'.
1020 # The providing packages are recorded as dependencies into package.env DEPEND
1021 # line, unless "--build-only" is passed as the very first argument, for jars
1022 # that have to be present only at build time and are not needed on runtime
1023 # (junit testing etc).
1024 #
1025 # @CODE
1026 # Example: Get the classpath for xerces-2 and xalan,
1027 # java-pkg_getjars xerces-2,xalan
1028 #
1029 # Example Return:
1030 # /usr/share/xerces-2/lib/xml-apis.jar:/usr/share/xerces-2/lib/xmlParserAPIs.jar:/usr/share/xalan/lib/xalan.jar
1031 #
1032 #
1033 # Parameters:
1034 # --build-only - makes the jar(s) not added into package.env DEPEND line.
1035 # (assumed automatically when called inside src_test)
1036 # --with-dependencies - get jars also from requested package's dependencies
1037 # transitively.
1038 # $1 - list of packages to get jars from
1039 # (passed to java-config --classpath)
1040 # @CODE
1041 java-pkg_getjars() {
1042 debug-print-function ${FUNCNAME} $*
1043
1044 local build_only=""
1045 local deep=""
1046
1047 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1048
1049 while [[ "${1}" == --* ]]; do
1050 if [[ "${1}" = "--build-only" ]]; then
1051 build_only="build"
1052 elif [[ "${1}" = "--with-dependencies" ]]; then
1053 deep="--with-dependencies"
1054 else
1055 die "java-pkg_jar-from called with unknown parameter: ${1}"
1056 fi
1057 shift
1058 done
1059
1060 [[ ${#} -ne 1 ]] && die "${FUNCNAME} takes only one argument besides --*"
1061
1062
1063 local pkgs="${1}"
1064
1065 if [[ "${EAPI}" == "1" ]]; then
1066 pkgs="${pkgs//:/-}"
1067 fi
1068
1069 jars="$(java-config ${deep} --classpath=${pkgs})"
1070 [[ $? != 0 ]] && die "java-config --classpath=${pkgs} failed"
1071 debug-print "${pkgs}:${jars}"
1072
1073 for pkg in ${pkgs//,/ }; do
1074 java-pkg_ensure-dep "${build_only}" "${pkg}"
1075 done
1076
1077 for pkg in ${pkgs//,/ }; do
1078 if [[ -z "${build_only}" ]]; then
1079 java-pkg_record-jar_ "${pkg}"
1080 else
1081 java-pkg_record-jar_ --build-only "${pkg}"
1082 fi
1083 done
1084
1085 echo "${jars}"
1086 }
1087
1088 # @FUNCTION: java-pkg_getjar
1089 # @USAGE: [--build-only] [--virtual] <package> <jarfile>
1090 # @DESCRIPTION:
1091 # Get the complete path of a single jar from a package
1092 # The providing package is recorded as runtime dependency into package.env
1093 # DEPEND line, unless "--build-only" is passed as the very first argument, for
1094 # jars that have to be present only at build time and are not needed on runtime
1095 # (junit testing etc).
1096 #
1097 # @CODE
1098 # Example:
1099 # java-pkg_getjar xerces-2 xml-apis.jar
1100 # returns
1101 # /usr/share/xerces-2/lib/xml-apis.jar
1102 #
1103 # Parameters:
1104 # --build-only - makes the jar not added into package.env DEPEND line.
1105 # --virtual - Packages passed to this function are to be handled as virtuals
1106 # and will not have individual jar dependencies recorded.
1107 # $1 - package to use
1108 # $2 - jar to get
1109 # @CODE
1110 java-pkg_getjar() {
1111 debug-print-function ${FUNCNAME} $*
1112
1113 local build_only=""
1114 local virtual=""
1115 local record_jar=""
1116
1117 [[ "${EBUILD_PHASE}" == "test" ]] && build_only="build"
1118
1119 while [[ "${1}" == --* ]]; do
1120 if [[ "${1}" = "--build-only" ]]; then
1121 build_only="build"
1122 elif [[ "${1}" == "--virtual" ]]; then
1123 virtual="true"
1124 else
1125 die "java-pkg_getjar called with unknown parameter: ${1}"
1126 fi
1127 shift
1128 done
1129
1130 [[ ${#} -ne 2 ]] && die "${FUNCNAME} takes only two arguments besides --*"
1131
1132 local pkg="${1}" target_jar="${2}" jar
1133
1134 if [[ "${EAPI}" == "1" ]]; then
1135 pkg="${pkg//:/-}"
1136 fi
1137
1138 [[ -z ${pkg} ]] && die "Must specify package to get a jar from"
1139 [[ -z ${target_jar} ]] && die "Must specify jar to get"
1140
1141 local error_msg="Could not find classpath for ${pkg}. Are you sure its installed?"
1142 local classpath
1143 classpath=$(java-config --classpath=${pkg})
1144 [[ $? != 0 ]] && die ${error_msg}
1145
1146 java-pkg_ensure-dep "${build_only}" "${pkg}"
1147
1148 # Record the package(Virtual) as a dependency and then set build_only
1149 # So that individual jars are not recorded.
1150 if [[ -n "${virtual}" ]]; then
1151 if [[ -z "${build_only}" ]]; then
1152 java-pkg_record-jar_ "${pkg}"
1153 else
1154 java-pkg_record-jar_ --build-only "${pkg}"
1155 fi
1156 record_jar="true"
1157 fi
1158
1159 for jar in ${classpath//:/ }; do
1160 if [[ ! -f "${jar}" ]] ; then
1161 die "Installation problem with jar ${jar} in ${pkg} - is it installed?"
1162 fi
1163
1164 if [[ "$(basename ${jar})" == "${target_jar}" ]] ; then
1165 # Only record jars that aren't build-only
1166 if [[ -z "${record_jar}" ]]; then
1167 if [[ -z "${build_only}" ]]; then
1168 java-pkg_record-jar_ "${pkg}" "${jar}"
1169 else
1170 java-pkg_record-jar_ --build-only "${pkg}" "${jar}"
1171 fi
1172 fi
1173 echo "${jar}"
1174 return 0
1175 fi
1176 done
1177
1178 die "Could not find ${target_jar} in ${pkg}"
1179 return 1
1180 }
1181
1182 # @FUNCTION: java-pkg_register-dependency
1183 # @USAGE: <package>[,<package2>...] [<jarfile>]
1184 # @DESCRIPTION:
1185 # Registers runtime dependency on a package, list of packages, or a single jar
1186 # from a package, into package.env DEPEND line. Can only be called in
1187 # src_install phase.
1188 # Intended for binary packages where you don't need to symlink the jars or get
1189 # their classpath during build. As such, the dependencies only need to be
1190 # specified in ebuild's RDEPEND, and should be omitted in DEPEND.
1191 #
1192 # @CODE
1193 # Parameters:
1194 # $1 - comma-separated list of packages, or a single package
1195 # $2 - if param $1 is a single package, optionally specify the jar
1196 # to depend on
1197 #
1198 # Examples:
1199 # Record the dependency on whole xerces-2 and xalan,
1200 # java-pkg_register-dependency xerces-2,xalan
1201 #
1202 # Record the dependency on ant.jar from ant-core
1203 # java-pkg_register-dependency ant-core ant.jar
1204 # @CODE
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 java-pkg_register-dependency() {
1212 debug-print-function ${FUNCNAME} $*
1213
1214 java-pkg_check-phase install
1215
1216 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1217
1218 local pkgs="${1}"
1219 local jar="${2}"
1220
1221 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1222
1223 if [[ "${EAPI}" == "1" ]]; then
1224 pkgs="${pkgs//:/-}"
1225 fi
1226
1227 if [[ -z "${jar}" ]]; then
1228 for pkg in ${pkgs//,/ }; do
1229 java-pkg_ensure-dep runtime "${pkg}"
1230 java-pkg_record-jar_ "${pkg}"
1231 done
1232 else
1233 [[ ${pkgs} == *,* ]] && \
1234 die "${FUNCNAME} called with both package list and jar name"
1235 java-pkg_ensure-dep runtime "${pkgs}"
1236 java-pkg_record-jar_ "${pkgs}" "${jar}"
1237 fi
1238
1239 java-pkg_do_write_
1240 }
1241
1242 # @FUNCTION: java-pkg_register-optional-dependency
1243 # @USAGE: <package>[,<package2>...] [<jarfile>]
1244 # @DESCRIPTION:
1245 # Registers optional runtime dependency on a package, list of packages, or a
1246 # single jar from a package, into package.env OPTIONAL_DEPEND line. Can only be
1247 # called in src_install phase.
1248 # Intended for packages that can use other packages when those are in classpath.
1249 # Will be put on classpath by launcher if they are installed. Typical case is
1250 # JDBC implementations for various databases. It's better than having USE flag
1251 # for each implementation triggering hard dependency.
1252 #
1253 # @CODE
1254 # Parameters:
1255 # $1 - comma-separated list of packages, or a single package
1256 # $2 - if param $1 is a single package, optionally specify the jar to depend on
1257 #
1258 # Example:
1259 # Record the optional dependency on some jdbc providers
1260 # java-pkg_register-optional-dependency jdbc-jaybird,jtds-1.2,jdbc-mysql
1261 # @CODE
1262 #
1263 # Note: Passing both list of packages as the first parameter AND specifying the
1264 # jar as the second is not allowed and will cause the function to die. We assume
1265 # that there's more chance one passes such combination as a mistake, than that
1266 # there are more packages providing identically named jar without class
1267 # collisions.
1268 java-pkg_register-optional-dependency() {
1269 debug-print-function ${FUNCNAME} $*
1270
1271 java-pkg_check-phase install
1272
1273 [[ ${#} -gt 2 ]] && die "${FUNCNAME} takes at most two arguments"
1274
1275 local pkgs="${1}"
1276 local jar="${2}"
1277
1278 [[ -z "${pkgs}" ]] && die "${FUNCNAME} called with no package(s) specified"
1279
1280 if [[ "${EAPI}" == "1" ]]; then
1281 pkgs="${pkgs//:/-}"
1282 fi
1283
1284 if [[ -z "${jar}" ]]; then
1285 for pkg in ${pkgs//,/ }; do
1286 java-pkg_record-jar_ --optional "${pkg}"
1287 done
1288 else
1289 [[ ${pkgs} == *,* ]] && \
1290 die "${FUNCNAME} called with both package list and jar name"
1291 java-pkg_record-jar_ --optional "${pkgs}" "${jar}"
1292 fi
1293
1294 java-pkg_do_write_
1295 }
1296
1297 # @FUNCTION: java-pkg_register-environment-variable
1298 # @USAGE: <name> <value>
1299 # @DESCRIPTION:
1300 # Register an arbitrary environment variable into package.env. The gjl launcher
1301 # for this package or any package depending on this will export it into
1302 # environement before executing java command.
1303 # Must only be called in src_install phase.
1304 JAVA_PKG_EXTRA_ENV="${T}/java-pkg-extra-env"
1305 JAVA_PKG_EXTRA_ENV_VARS=""
1306 java-pkg_register-environment-variable() {
1307 debug-print-function ${FUNCNAME} $*
1308
1309 java-pkg_check-phase install
1310
1311 [[ ${#} != 2 ]] && die "${FUNCNAME} takes two arguments"
1312
1313 echo "${1}=\"${2}\"" >> ${JAVA_PKG_EXTRA_ENV}
1314 JAVA_PKG_EXTRA_ENV_VARS="${JAVA_PKG_EXTRA_ENV_VARS} ${1}"
1315
1316 java-pkg_do_write_
1317 }
1318
1319 # @FUNCTION: java-pkg_get-bootclasspath
1320 # @USAGE: <version>
1321 # @DESCRIPTION:
1322 # Returns classpath of a given bootclasspath-providing package version.
1323 #
1324 # @param $1 - the version of bootclasspath (e.g. 1.5), 'auto' for bootclasspath
1325 # of the current JDK
1326 java-pkg_get-bootclasspath() {
1327 local version="${1}"
1328
1329 local bcp
1330 case "${version}" in
1331 auto)
1332 bcp="$(java-config -g BOOTCLASSPATH)"
1333 ;;
1334 1.5)
1335 bcp="$(java-pkg_getjars --build-only gnu-classpath-0.98)"
1336 ;;
1337 *)
1338 eerror "unknown parameter of java-pkg_get-bootclasspath"
1339 die "unknown parameter of java-pkg_get-bootclasspath"
1340 ;;
1341 esac
1342
1343 echo "${bcp}"
1344 }
1345
1346
1347 # This function reads stdin, and based on that input, figures out how to
1348 # populate jars from the filesystem.
1349 # Need to figure out a good way of making use of this, ie be able to use a
1350 # string that was built instead of stdin
1351 # NOTE: this isn't quite ready for primetime.
1352 #java-pkg_populate-jars() {
1353 # local line
1354 #
1355 # read line
1356 # while [[ -n "${line}" ]]; do
1357 # # Ignore comments
1358 # [[ ${line%%#*} == "" ]] && continue
1359 #
1360 # # get rid of any spaces
1361 # line="${line// /}"
1362 #
1363 # # format: path=jarinfo
1364 # local path=${line%%=*}
1365 # local jarinfo=${line##*=}
1366 #
1367 # # format: jar@package
1368 # local jar=${jarinfo%%@*}.jar
1369 # local package=${jarinfo##*@}
1370 # if [[ -n ${replace_only} ]]; then
1371 # [[ ! -f $path ]] && die "No jar exists at ${path}"
1372 # fi
1373 # if [[ -n ${create_parent} ]]; then
1374 # local parent=$(dirname ${path})
1375 # mkdir -p "${parent}"
1376 # fi
1377 # java-pkg_jar-from "${package}" "${jar}" "${path}"
1378 #
1379 # read line
1380 # done
1381 #}
1382
1383 # @FUNCTION: java-pkg_find-normal-jars
1384 # @USAGE: [<path/to/directory>]
1385 # @DESCRIPTION:
1386 # Find the files with suffix .jar file in the given directory (default: $WORKDIR)
1387 java-pkg_find-normal-jars() {
1388 local dir=$1
1389 [[ "${dir}" ]] || dir="${WORKDIR}"
1390 local found
1391 for jar in $(find "${dir}" -name "*.jar" -type f); do
1392 echo "${jar}"
1393 found="true"
1394 done
1395 [[ "${found}" ]]
1396 return $?
1397 }
1398
1399 # @FUNCTION: java-pkg_ensure-no-bundled-jars
1400 # @DESCRIPTION:
1401 # Try to locate bundled jar files in ${WORKDIR} and die if found.
1402 # This function should be called after WORKDIR has been populated with symlink
1403 # to system jar files or bundled jars removed.
1404 java-pkg_ensure-no-bundled-jars() {
1405 debug-print-function ${FUNCNAME} $*
1406
1407 local bundled_jars=$(java-pkg_find-normal-jars)
1408 if [[ -n ${bundled_jars} ]]; then
1409 echo "Bundled jars found:"
1410 local jar
1411 for jar in ${bundled_jars}; do
1412 echo $(pwd)${jar/./}
1413 done
1414 die "Bundled jars found!"
1415 fi
1416 }
1417
1418 # @FUNCTION: java-pkg_ensure-vm-version-sufficient
1419 # @INTERNAL
1420 # @DESCRIPTION:
1421 # Checks if we have a sufficient VM and dies if we don't.
1422 java-pkg_ensure-vm-version-sufficient() {
1423 debug-print-function ${FUNCNAME} $*
1424
1425 if ! java-pkg_is-vm-version-sufficient; then
1426 debug-print "VM is not suffient"
1427 eerror "Current Java VM cannot build this package"
1428 einfo "Please use java-config -S to set the correct one"
1429 die "Active Java VM cannot build this package"
1430 fi
1431 }
1432
1433 # @FUNCTION: java-pkg_is-vm-version-sufficient
1434 # @INTERNAL
1435 # @DESCRIPTION:
1436 # @RETURN: zero - VM is sufficient; non-zero - VM is not sufficient
1437 java-pkg_is-vm-version-sufficient() {
1438 debug-print-function ${FUNCNAME} $*
1439
1440 depend-java-query --is-sufficient "${DEPEND}" > /dev/null
1441 return $?
1442 }
1443
1444 # @FUNCTION: java-pkg_ensure-vm-version-eq
1445 # @INTERNAL
1446 # @DESCRIPTION:
1447 # Die if the current VM is not equal to the argument passed.
1448 #
1449 # @param $@ - Desired VM version to ensure
1450 java-pkg_ensure-vm-version-eq() {
1451 debug-print-function ${FUNCNAME} $*
1452
1453 if ! java-pkg_is-vm-version-eq $@ ; then
1454 debug-print "VM is not suffient"
1455 eerror "This package requires a Java VM version = $@"
1456 einfo "Please use java-config -S to set the correct one"
1457 die "Active Java VM too old"
1458 fi
1459 }
1460
1461 # @FUNCTION: java-pkg_is-vm-version-eq
1462 # @USAGE: <version>
1463 # @INTERNAL
1464 # @RETURN: zero - VM versions are equal; non-zero - VM version are not equal
1465 java-pkg_is-vm-version-eq() {
1466 debug-print-function ${FUNCNAME} $*
1467
1468 local needed_version="$@"
1469
1470 [[ -z "${needed_version}" ]] && die "need an argument"
1471
1472 local vm_version="$(java-pkg_get-vm-version)"
1473
1474 vm_version="$(get_version_component_range 1-2 "${vm_version}")"
1475 needed_version="$(get_version_component_range 1-2 "${needed_version}")"
1476
1477 if [[ -z "${vm_version}" ]]; then
1478 debug-print "Could not get JDK version from DEPEND"
1479 return 1
1480 else
1481 if [[ "${vm_version}" == "${needed_version}" ]]; then
1482 debug-print "Detected a JDK(${vm_version}) = ${needed_version}"
1483 return 0
1484 else
1485 debug-print "Detected a JDK(${vm_version}) != ${needed_version}"
1486 return 1
1487 fi
1488 fi
1489 }
1490
1491 # @FUNCTION: java-pkg_ensure-vm-version-ge
1492 # @INTERNAL
1493 # @DESCRIPTION:
1494 # Die if the current VM is not greater than the desired version
1495 #
1496 # @param $@ - VM version to compare current to
1497 java-pkg_ensure-vm-version-ge() {
1498 debug-print-function ${FUNCNAME} $*
1499
1500 if ! java-pkg_is-vm-version-ge "$@" ; then
1501 debug-print "vm is not suffient"
1502 eerror "This package requires a Java VM version >= $@"
1503 einfo "Please use java-config -S to set the correct one"
1504 die "Active Java VM too old"
1505 fi
1506 }
1507
1508 # @FUNCTION: java-pkg_is-vm-version-ge
1509 # @INTERNAL
1510 # @DESCRIPTION:
1511 # @CODE
1512 # Parameters:
1513 # $@ - VM version to compare current VM to
1514 # @CODE
1515 # @RETURN: zero - current VM version is greater than checked version;
1516 # non-zero - current VM version is not greater than checked version
1517 java-pkg_is-vm-version-ge() {
1518 debug-print-function ${FUNCNAME} $*
1519
1520 local needed_version=$@
1521 local vm_version=$(java-pkg_get-vm-version)
1522 if [[ -z "${vm_version}" ]]; then
1523 debug-print "Could not get JDK version from DEPEND"
1524 return 1
1525 else
1526 if version_is_at_least "${needed_version}" "${vm_version}"; then
1527 debug-print "Detected a JDK(${vm_version}) >= ${needed_version}"
1528 return 0
1529 else
1530 debug-print "Detected a JDK(${vm_version}) < ${needed_version}"
1531 return 1
1532 fi
1533 fi
1534 }
1535
1536 java-pkg_set-current-vm() {
1537 export GENTOO_VM=${1}
1538 }
1539
1540 java-pkg_get-current-vm() {
1541 echo ${GENTOO_VM}
1542 }
1543
1544 java-pkg_current-vm-matches() {
1545 has $(java-pkg_get-current-vm) ${@}
1546 return $?
1547 }
1548
1549 # @FUNCTION: java-pkg_get-source
1550 # @DESCRIPTION:
1551 # Determines what source version should be used, for passing to -source.
1552 # Unless you want to break things you probably shouldn't set _WANT_SOURCE
1553 #
1554 # @RETURN: string - Either the lowest possible source, or JAVA_PKG_WANT_SOURCE
1555 java-pkg_get-source() {
1556 echo ${JAVA_PKG_WANT_SOURCE:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1557 }
1558
1559 # @FUNCTION: java-pkg_get-target
1560 # @DESCRIPTION:
1561 # Determines what target version should be used, for passing to -target.
1562 # If you don't care about lower versions, you can set _WANT_TARGET to the
1563 # version of your JDK.
1564 #
1565 # @RETURN: string - Either the lowest possible target, or JAVA_PKG_WANT_TARGET
1566 java-pkg_get-target() {
1567 echo ${JAVA_PKG_WANT_TARGET:-$(depend-java-query --get-lowest "${DEPEND} ${RDEPEND}")}
1568 }
1569
1570 # @FUNCTION: java-pkg_get-javac
1571 # @DESCRIPTION:
1572 # Returns the compiler executable
1573 java-pkg_get-javac() {
1574 debug-print-function ${FUNCNAME} $*
1575
1576
1577 local compiler="${GENTOO_COMPILER}"
1578
1579 local compiler_executable
1580 if [[ "${compiler}" = "javac" ]]; then
1581 # nothing fancy needs to be done for javac
1582 compiler_executable="javac"
1583 else
1584 # for everything else, try to determine from an env file
1585
1586 local compiler_env="/usr/share/java-config-2/compiler/${compiler}"
1587 if [[ -f ${compiler_env} ]]; then
1588 local old_javac=${JAVAC}
1589 unset JAVAC
1590 # try to get value of JAVAC
1591 compiler_executable="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${JAVAC})"
1592 export JAVAC=${old_javac}
1593
1594 if [[ -z ${compiler_executable} ]]; then
1595 echo "JAVAC is empty or undefined in ${compiler_env}"
1596 return 1
1597 fi
1598
1599 # check that it's executable
1600 if [[ ! -x ${compiler_executable} ]]; then
1601 echo "${compiler_executable} doesn't exist, or isn't executable"
1602 return 1
1603 fi
1604 else
1605 echo "Could not find environment file for ${compiler}"
1606 return 1
1607 fi
1608 fi
1609 echo ${compiler_executable}
1610 }
1611
1612 # @FUNCTION: java-pkg_javac-args
1613 # @DESCRIPTION:
1614 # If an ebuild uses javac directly, instead of using ejavac, it should call this
1615 # to know what -source/-target to use.
1616 #
1617 # @RETURN: string - arguments to pass to javac, complete with -target and -source
1618 java-pkg_javac-args() {
1619 debug-print-function ${FUNCNAME} $*
1620
1621 local want_source="$(java-pkg_get-source)"
1622 local want_target="$(java-pkg_get-target)"
1623
1624 local source_str="-source ${want_source}"
1625 local target_str="-target ${want_target}"
1626
1627 debug-print "want source: ${want_source}"
1628 debug-print "want target: ${want_target}"
1629
1630 if [[ -z "${want_source}" || -z "${want_target}" ]]; then
1631 debug-print "could not find valid -source/-target values for javac"
1632 echo "Could not find valid -source/-target values for javac"
1633 return 1
1634 else
1635 echo "${source_str} ${target_str}"
1636 fi
1637 }
1638
1639 # @FUNCTION: java-pkg_get-jni-cflags
1640 # @DESCRIPTION:
1641 # Echos the CFLAGS for JNI compilations
1642 java-pkg_get-jni-cflags() {
1643 local flags="-I${JAVA_HOME}/include"
1644
1645 local platform="linux"
1646 use elibc_FreeBSD && platform="freebsd"
1647
1648 # TODO do a check that the directories are valid
1649 flags="${flags} -I${JAVA_HOME}/include/${platform}"
1650
1651 echo ${flags}
1652 }
1653
1654 java-pkg_ensure-gcj() {
1655 # was enforcing sys-devel/gcc[gcj]
1656 die "${FUNCNAME} was removed. Use use-deps available as of EAPI 2 instead. #261562"
1657 }
1658
1659 java-pkg_ensure-test() {
1660 # was enforcing USE=test if FEATURES=test
1661 die "${FUNCNAME} was removed. Package mangers handle this already. #278965"
1662 }
1663
1664 # @FUNCTION: java-pkg_register-ant-task
1665 # @USAGE: [--version x.y] [<name>]
1666 # @DESCRIPTION:
1667 # Register this package as ant task, so that ant will load it when no specific
1668 # ANT_TASKS are specified. Note that even without this registering, all packages
1669 # specified in ANT_TASKS will be loaded. Mostly used by the actual ant tasks
1670 # packages, but can be also used by other ebuilds that used to symlink their
1671 # .jar into /usr/share/ant-core/lib to get autoloaded, for backwards
1672 # compatibility.
1673 #
1674 # @CODE
1675 # Parameters
1676 # --version x.y Register only for ant version x.y (otherwise for any ant
1677 # version). Used by the ant-* packages to prevent loading of mismatched
1678 # ant-core ant tasks after core was updated, before the tasks are updated,
1679 # without a need for blockers.
1680 # $1 Name to register as. Defaults to JAVA_PKG_NAME ($PN[-$SLOT])
1681 # @CODE
1682 java-pkg_register-ant-task() {
1683 local TASKS_DIR="tasks"
1684
1685 # check for --version x.y parameters
1686 while [[ -n "${1}" && -n "${2}" ]]; do
1687 local var="${1#--}"
1688 local val="${2}"
1689 if [[ "${var}" == "version" ]]; then
1690 TASKS_DIR="tasks-${val}"
1691 else
1692 die "Unknown parameter passed to java-pkg_register-ant-tasks: ${1} ${2}"
1693 fi
1694 shift 2
1695 done
1696
1697 local TASK_NAME="${1:-${JAVA_PKG_NAME}}"
1698
1699 dodir /usr/share/ant/${TASKS_DIR}
1700 touch "${D}/usr/share/ant/${TASKS_DIR}/${TASK_NAME}"
1701 }
1702
1703 # @FUNCTION: java-pkg_ant-tasks-depend
1704 # @INTERNAL
1705 # @DESCRIPTION:
1706 # Translates the WANT_ANT_TASKS variable into valid dependencies.
1707 java-pkg_ant-tasks-depend() {
1708 debug-print-function ${FUNCNAME} ${WANT_ANT_TASKS}
1709
1710 if [[ -n "${WANT_ANT_TASKS}" ]]; then
1711 local DEP=""
1712 for i in ${WANT_ANT_TASKS}
1713 do
1714 if [[ ${i} = ant-* ]]; then
1715 DEP="${DEP}dev-java/${i} "
1716 elif [[ ${i} = */*:* ]]; then
1717 DEP="${DEP}${i} "
1718 else
1719 echo "Invalid atom in WANT_ANT_TASKS: ${i}"
1720 return 1
1721 fi
1722 done
1723 echo ${DEP}
1724 return 0
1725 else
1726 return 0
1727 fi
1728 }
1729
1730
1731 # @FUNCTION: ejunit_
1732 # @INTERNAL
1733 # @DESCRIPTION:
1734 # Internal Junit wrapper function. Makes it easier to run the tests and checks for
1735 # dev-java/junit in DEPEND. Launches the tests using junit.textui.TestRunner.
1736 # @CODE
1737 # Parameters:
1738 # $1 - junit package (junit or junit-4)
1739 # $2 - -cp or -classpath
1740 # $3 - classpath; junit and recorded dependencies get appended
1741 # $@ - the rest of the parameters are passed to java
1742 # @CODE
1743 ejunit_() {
1744 debug-print-function ${FUNCNAME} $*
1745
1746 local pkgs
1747 if [[ -f ${JAVA_PKG_DEPEND_FILE} ]]; then
1748 for atom in $(cat ${JAVA_PKG_DEPEND_FILE} | tr : ' '); do
1749 pkgs=${pkgs},$(echo ${atom} | sed -re "s/^.*@//")
1750 done
1751 fi
1752
1753 local junit=${1}
1754 shift 1
1755
1756 local cp=$(java-pkg_getjars --with-dependencies ${junit}${pkgs})
1757 if [[ ${1} = -cp || ${1} = -classpath ]]; then
1758 cp="${2}:${cp}"
1759 shift 2
1760 else
1761 cp=".:${cp}"
1762 fi
1763
1764 local runner=junit.textui.TestRunner
1765 if [[ "${junit}" == "junit-4" ]] ; then
1766 runner=org.junit.runner.JUnitCore
1767 fi
1768 debug-print "Calling: java -cp \"${cp}\" -Djava.awt.headless=true ${runner} ${@}"
1769 java -cp "${cp}" -Djava.awt.headless=true ${runner} "${@}" || die "Running junit failed"
1770 }
1771
1772 # @FUNCTION: ejunit
1773 # @DESCRIPTION:
1774 # Junit wrapper function. Makes it easier to run the tests and checks for
1775 # dev-java/junit in DEPEND. Launches the tests using org.junit.runner.JUnitCore.
1776 #
1777 # @CODE
1778 # Parameters:
1779 # $1 - -cp or -classpath
1780 # $2 - classpath; junit and recorded dependencies get appended
1781 # $@ - the rest of the parameters are passed to java
1782 #
1783 # Examples:
1784 # ejunit -cp build/classes org.blinkenlights.jid3.test.AllTests
1785 # ejunit org.blinkenlights.jid3.test.AllTests
1786 # ejunit org.blinkenlights.jid3.test.FirstTest org.blinkenlights.jid3.test.SecondTest
1787 # @CODE
1788 ejunit() {
1789 debug-print-function ${FUNCNAME} $*
1790
1791 ejunit_ "junit" "${@}"
1792 }
1793
1794 # @FUNCTION: ejunit4
1795 # @DESCRIPTION:
1796 # Junit4 wrapper function. Makes it easier to run the tests and checks for
1797 # dev-java/junit:4 in DEPEND. Launches the tests using junit.textui.TestRunner.
1798 #
1799 # @CODE
1800 # Parameters:
1801 # $1 - -cp or -classpath
1802 # $2 - classpath; junit and recorded dependencies get appended
1803 # $@ - the rest of the parameters are passed to java
1804 #
1805 # Examples:
1806 # ejunit4 -cp build/classes org.blinkenlights.jid3.test.AllTests
1807 # ejunit4 org.blinkenlights.jid3.test.AllTests
1808 # ejunit4 org.blinkenlights.jid3.test.FirstTest \
1809 # org.blinkenlights.jid3.test.SecondTest
1810 # @CODE
1811 ejunit4() {
1812 debug-print-function ${FUNCNAME} $*
1813
1814 ejunit_ "junit-4" "${@}"
1815 }
1816
1817 # @FUNCTION: java-utils-2_src_prepare
1818 # @DESCRIPTION:
1819 # src_prepare Searches for bundled jars
1820 # Don't call directly, but via java-pkg-2_src_prepare!
1821 java-utils-2_src_prepare() {
1822 java-pkg_func-exists java_prepare && java_prepare
1823
1824 # Check for files in JAVA_RM_FILES array.
1825 if [[ ${JAVA_RM_FILES[@]} ]]; then
1826 debug-print "$FUNCNAME: removing unneeded files"
1827 java-pkg_rm_files "${JAVA_RM_FILES[@]}"
1828 fi
1829
1830 if is-java-strict; then
1831 echo "Searching for bundled jars:"
1832 java-pkg_find-normal-jars || echo "None found."
1833 echo "Searching for bundled classes (no output if none found):"
1834 find "${WORKDIR}" -name "*.class"
1835 echo "Search done."
1836 fi
1837 }
1838
1839 # @FUNCTION: java-utils-2_pkg_preinst
1840 # @DESCRIPTION:
1841 # pkg_preinst Searches for missing and unneeded dependencies
1842 # Don't call directly, but via java-pkg-2_pkg_preinst!
1843 java-utils-2_pkg_preinst() {
1844 if is-java-strict; then
1845 if [[ ! -e "${JAVA_PKG_ENV}" ]] || has ant-tasks ${INHERITED}; then
1846 return
1847 fi
1848
1849 if has_version dev-java/java-dep-check; then
1850 local output=$(GENTOO_VM= java-dep-check --image "${D}" "${JAVA_PKG_ENV}")
1851 [[ ${output} ]] && ewarn "${output}"
1852 else
1853 eerror "Install dev-java/java-dep-check for dependency checking"
1854 fi
1855 fi
1856 }
1857
1858 # @FUNCTION: eant
1859 # @USAGE: <ant_build_target(s)>
1860 # @DESCRIPTION:
1861 # Ant wrapper function. Will use the appropriate compiler, based on user-defined
1862 # compiler. Will also set proper ANT_TASKS from the variable ANT_TASKS,
1863 # variables:
1864 #
1865 # @CODE
1866 # Variables:
1867 # EANT_GENTOO_CLASSPATH - calls java-pkg_getjars for the value and adds to the
1868 # gentoo.classpath property. Be sure to call java-ant_rewrite-classpath in src_unpack.
1869 # EANT_NEEDS_TOOLS - add tools.jar to the gentoo.classpath. Should only be used
1870 # for build-time purposes, the dependency is not recorded to
1871 # package.env!
1872 # ANT_TASKS - used to determine ANT_TASKS before calling Ant.
1873 # @CODE
1874 eant() {
1875 debug-print-function ${FUNCNAME} $*
1876
1877 if [[ ${EBUILD_PHASE} = compile ]]; then
1878 java-ant-2_src_configure
1879 fi
1880
1881 if ! has java-ant-2 ${INHERITED}; then
1882 local msg="You should inherit java-ant-2 when using eant"
1883 java-pkg_announce-qa-violation "${msg}"
1884 fi
1885
1886 local antflags="-Dnoget=true -Dmaven.mode.offline=true -Dbuild.sysclasspath=ignore"
1887
1888 java-pkg_init-compiler_
1889 local compiler="${GENTOO_COMPILER}"
1890
1891 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
1892 local build_compiler="$(source ${compiler_env} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER})"
1893 if [[ "${compiler}" != "javac" && -z "${build_compiler}" ]]; then
1894 die "ANT_BUILD_COMPILER undefined in ${compiler_env}"
1895 fi
1896
1897 if [[ ${compiler} != "javac" ]]; then
1898 antflags="${antflags} -Dbuild.compiler=${build_compiler}"
1899 # Figure out any extra stuff to put on the classpath for compilers aside
1900 # from javac
1901 # ANT_BUILD_COMPILER_DEPS should be something that could be passed to
1902 # java-config -p
1903 local build_compiler_deps="$(source ${JAVA_PKG_COMPILER_DIR}/${compiler} 1>/dev/null 2>&1; echo ${ANT_BUILD_COMPILER_DEPS})"
1904 if [[ -n ${build_compiler_deps} ]]; then
1905 antflags="${antflags} -lib $(java-config -p ${build_compiler_deps})"
1906 fi
1907 fi
1908
1909 for arg in "${@}"; do
1910 if [[ ${arg} = -lib ]]; then
1911 if is-java-strict; then
1912 eerror "You should not use the -lib argument to eant because it will fail"
1913 eerror "with JAVA_PKG_STRICT. Please use for example java-pkg_jar-from"
1914 eerror "or ant properties to make dependencies available."
1915 eerror "For ant tasks use WANT_ANT_TASKS or ANT_TASKS from."
1916 eerror "split ant (>=dev-java/ant-core-1.7)."
1917 die "eant -lib is deprecated/forbidden"
1918 else
1919 echo "eant -lib is deprecated. Turn JAVA_PKG_STRICT on for"
1920 echo "more info."
1921 fi
1922 fi
1923 done
1924
1925 # parse WANT_ANT_TASKS for atoms
1926 local want_ant_tasks
1927 for i in ${WANT_ANT_TASKS}; do
1928 if [[ ${i} = */*:* ]]; then
1929 i=${i#*/}
1930 i=${i%:0}
1931 want_ant_tasks+="${i/:/-} "
1932 else
1933 want_ant_tasks+="${i} "
1934 fi
1935 done
1936 # default ANT_TASKS to WANT_ANT_TASKS, if ANT_TASKS is not set explicitly
1937 ANT_TASKS="${ANT_TASKS:-${want_ant_tasks% }}"
1938
1939 # override ANT_TASKS with JAVA_PKG_FORCE_ANT_TASKS if it's set
1940 ANT_TASKS="${JAVA_PKG_FORCE_ANT_TASKS:-${ANT_TASKS}}"
1941
1942 # if ant-tasks is not set by ebuild or forced, use none
1943 ANT_TASKS="${ANT_TASKS:-none}"
1944
1945 # at this point, ANT_TASKS should be "all", "none" or explicit list
1946 if [[ "${ANT_TASKS}" == "all" ]]; then
1947 einfo "Using all available ANT_TASKS"
1948 elif [[ "${ANT_TASKS}" == "none" ]]; then
1949 einfo "Disabling all optional ANT_TASKS"
1950 else
1951 einfo "Using following ANT_TASKS: ${ANT_TASKS}"
1952 fi
1953
1954 export ANT_TASKS
1955
1956 [[ -n ${JAVA_PKG_DEBUG} ]] && antflags="${antflags} --execdebug -debug"
1957 [[ -n ${PORTAGE_QUIET} ]] && antflags="${antflags} -q"
1958
1959 local gcp="${EANT_GENTOO_CLASSPATH}"
1960 local getjarsarg=""
1961
1962 if [[ ${EBUILD_PHASE} = "test" ]]; then
1963 antflags="${antflags} -DJunit.present=true"
1964 getjarsarg="--with-dependencies"
1965
1966 local re="\bant-junit4?([-:]\S+)?\b"
1967 [[ ${ANT_TASKS} =~ ${re} ]] && gcp+=" ${BASH_REMATCH[0]}"
1968 else
1969 antflags="${antflags} -Dmaven.test.skip=true"
1970 fi
1971
1972 local cp
1973
1974 for atom in ${gcp}; do
1975 cp+=":$(java-pkg_getjars ${getjarsarg} ${atom})"
1976 done
1977
1978 [[ ${EANT_NEEDS_TOOLS} ]] && cp+=":$(java-config --tools)"
1979 [[ ${EANT_GENTOO_CLASSPATH_EXTRA} ]] && cp+=":${EANT_GENTOO_CLASSPATH_EXTRA}"
1980
1981 if [[ ${cp#:} ]]; then
1982 # It seems ant does not like single quotes around ${cp}
1983 antflags="${antflags} -Dgentoo.classpath=\"${cp#:}\""
1984 fi
1985
1986 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ant ${antflags} "${@}"
1987 debug-print "Calling ant (GENTOO_VM: ${GENTOO_VM}): ${antflags} ${@}"
1988 ant ${antflags} "${@}" || die "eant failed"
1989 }
1990
1991 # @FUNCTION: ejavac
1992 # @USAGE: <javac_arguments>
1993 # @DESCRIPTION:
1994 # Javac wrapper function. Will use the appropriate compiler, based on
1995 # /etc/java-config/compilers.conf
1996 ejavac() {
1997 debug-print-function ${FUNCNAME} $*
1998
1999 java-pkg_init-compiler_
2000
2001 local compiler_executable
2002 compiler_executable=$(java-pkg_get-javac)
2003 if [[ ${?} != 0 ]]; then
2004 eerror "There was a problem determining compiler: ${compiler_executable}"
2005 die "get-javac failed"
2006 fi
2007
2008 local javac_args
2009 javac_args="$(java-pkg_javac-args)"
2010 if [[ ${?} != 0 ]]; then
2011 eerror "There was a problem determining JAVACFLAGS: ${javac_args}"
2012 die "java-pkg_javac-args failed"
2013 fi
2014
2015 [[ -n ${JAVA_PKG_DEBUG} ]] && echo ${compiler_executable} ${javac_args} "${@}"
2016 ${compiler_executable} ${javac_args} "${@}" || die "ejavac failed"
2017 }
2018
2019 # @FUNCTION: ejavadoc
2020 # @USAGE: <javadoc_arguments>
2021 # @DESCRIPTION:
2022 # javadoc wrapper function. Will set some flags based on the VM version
2023 # due to strict javadoc rules in 1.8.
2024 ejavadoc() {
2025 debug-print-function ${FUNCNAME} $*
2026
2027 local javadoc_args=""
2028
2029 if java-pkg_is-vm-version-ge "1.8" ; then
2030 javadoc_args="-Xdoclint:none"
2031 fi
2032
2033 javadoc ${javadoc_args} "${@}" || die "ejavadoc failed"
2034 }
2035
2036 # @FUNCTION: java-pkg_filter-compiler
2037 # @USAGE: <compiler(s)_to_filter>
2038 # @DESCRIPTION:
2039 # Used to prevent the use of some compilers. Should be used in src_compile.
2040 # Basically, it just appends onto JAVA_PKG_FILTER_COMPILER
2041 java-pkg_filter-compiler() {
2042 JAVA_PKG_FILTER_COMPILER="${JAVA_PKG_FILTER_COMPILER} $@"
2043 }
2044
2045 # @FUNCTION: java-pkg_force-compiler
2046 # @USAGE: <compiler(s)_to_force>
2047 # @DESCRIPTION:
2048 # Used to force the use of particular compilers. Should be used in src_compile.
2049 # A common use of this would be to force ecj-3.1 to be used on amd64, to avoid
2050 # OutOfMemoryErrors that may come up.
2051 java-pkg_force-compiler() {
2052 JAVA_PKG_FORCE_COMPILER="$@"
2053 }
2054
2055 # @FUNCTION: use_doc
2056 # @DESCRIPTION:
2057 #
2058 # Helper function for getting ant to build javadocs. If the user has USE=doc,
2059 # then 'javadoc' or the argument are returned. Otherwise, there is no return.
2060 #
2061 # The output of this should be passed to ant.
2062 # @CODE
2063 # Parameters:
2064 # $@ - Option value to return. Defaults to 'javadoc'
2065 #
2066 # Examples:
2067 # build javadocs by calling 'javadoc' target
2068 # eant $(use_doc)
2069 #
2070 # build javadocs by calling 'apidoc' target
2071 # eant $(use_doc apidoc)
2072 # @CODE
2073 # @RETURN string - Name of the target to create javadocs
2074 use_doc() {
2075 use doc && echo ${@:-javadoc}
2076 }
2077
2078
2079 # @FUNCTION: java-pkg_init
2080 # @INTERNAL
2081 # @DESCRIPTION:
2082 # The purpose of this function, as the name might imply, is to initialize the
2083 # Java environment. It ensures that that there aren't any environment variables
2084 # that'll muss things up. It initializes some variables, which are used
2085 # internally. And most importantly, it'll switch the VM if necessary.
2086 #
2087 # This shouldn't be used directly. Instead, java-pkg and java-pkg-opt will
2088 # call it during each of the phases of the merge process.
2089 java-pkg_init() {
2090 debug-print-function ${FUNCNAME} $*
2091
2092 # Don't set up build environment if installing from binary. #206024 #258423
2093 [[ "${MERGE_TYPE}" == "binary" ]] && return
2094 # Also try Portage's nonstandard EMERGE_FROM for old EAPIs, if it doesn't
2095 # work nothing is lost.
2096 has ${EAPI:-0} 0 1 2 3 && [[ "${EMERGE_FROM}" == "binary" ]] && return
2097
2098 unset JAVAC
2099 unset JAVA_HOME
2100
2101 java-config --help >/dev/null || {
2102 eerror ""
2103 eerror "Can't run java-config --help"
2104 eerror "Have you upgraded python recently but haven't"
2105 eerror "run python-updater yet?"
2106 die "Can't run java-config --help"
2107 }
2108
2109 # People do all kinds of weird things.
2110 # http://forums.gentoo.org/viewtopic-p-3943166.html
2111 local silence="${SILENCE_JAVA_OPTIONS_WARNING}"
2112 local accept="${I_WANT_GLOBAL_JAVA_OPTIONS}"
2113 if [[ -n ${_JAVA_OPTIONS} && -z ${accept} && -z ${silence} ]]; then
2114 ewarn "_JAVA_OPTIONS changes what java -version outputs at least for"
2115 ewarn "sun-jdk vms and and as such break configure scripts that"
2116 ewarn "use it (for example app-office/openoffice) so we filter it out."
2117 ewarn "Use SILENCE_JAVA_OPTIONS_WARNING=true in the environment (use"
2118 ewarn "make.conf for example) to silence this warning or"
2119 ewarn "I_WANT_GLOBAL_JAVA_OPTIONS to not filter it."
2120 fi
2121
2122 if [[ -z ${accept} ]]; then
2123 # export _JAVA_OPTIONS= doesn't work because it will show up in java
2124 # -version output
2125 unset _JAVA_OPTIONS
2126 # phase hooks make this run many times without this
2127 I_WANT_GLOBAL_JAVA_OPTIONS="true"
2128 fi
2129
2130 if java-pkg_func-exists ant_src_unpack; then
2131 java-pkg_announce-qa-violation "Using old ant_src_unpack. Should be src_unpack"
2132 fi
2133
2134 java-pkg_switch-vm
2135 PATH=${JAVA_HOME}/bin:${PATH}
2136
2137 # TODO we will probably want to set JAVAC and JAVACFLAGS
2138
2139 # Do some QA checks
2140 java-pkg_check-jikes
2141
2142 # Can't use unset here because Portage does not save the unset
2143 # see https://bugs.gentoo.org/show_bug.cgi?id=189417#c11
2144
2145 # When users have crazy classpaths some packages can fail to compile.
2146 # and everything should work with empty CLASSPATH.
2147 # This also helps prevent unexpected dependencies on random things
2148 # from the CLASSPATH.
2149 export CLASSPATH=
2150
2151 # Unset external ANT_ stuff
2152 export ANT_TASKS=
2153 export ANT_OPTS=
2154 export ANT_RESPECT_JAVA_HOME=
2155 }
2156
2157 # @FUNCTION: java-pkg-init-compiler_
2158 # @INTERNAL
2159 # @DESCRIPTION:
2160 # This function attempts to figure out what compiler should be used. It does
2161 # this by reading the file at JAVA_PKG_COMPILERS_CONF, and checking the
2162 # COMPILERS variable defined there.
2163 # This can be overridden by a list in JAVA_PKG_FORCE_COMPILER
2164 #
2165 # It will go through the list of compilers, and verify that it supports the
2166 # target and source that are needed. If it is not suitable, then the next
2167 # compiler is checked. When JAVA_PKG_FORCE_COMPILER is defined, this checking
2168 # isn't done.
2169 #
2170 # Once the which compiler to use has been figured out, it is set to
2171 # GENTOO_COMPILER.
2172 #
2173 # If you hadn't guessed, JAVA_PKG_FORCE_COMPILER is for testing only.
2174 #
2175 # If the user doesn't defined anything in JAVA_PKG_COMPILERS_CONF, or no
2176 # suitable compiler was found there, then the default is to use javac provided
2177 # by the current VM.
2178 #
2179 #
2180 # @RETURN name of the compiler to use
2181 java-pkg_init-compiler_() {
2182 debug-print-function ${FUNCNAME} $*
2183
2184 if [[ -n ${GENTOO_COMPILER} ]]; then
2185 debug-print "GENTOO_COMPILER already set"
2186 return
2187 fi
2188
2189 local compilers;
2190 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
2191 compilers="$(source ${JAVA_PKG_COMPILERS_CONF} 1>/dev/null 2>&1; echo ${COMPILERS})"
2192 else
2193 compilers=${JAVA_PKG_FORCE_COMPILER}
2194 fi
2195
2196 debug-print "Read \"${compilers}\" from ${JAVA_PKG_COMPILERS_CONF}"
2197
2198 # Figure out if we should announce what compiler we're using
2199 local compiler
2200 for compiler in ${compilers}; do
2201 debug-print "Checking ${compiler}..."
2202 # javac should always be alright
2203 if [[ ${compiler} = "javac" ]]; then
2204 debug-print "Found javac... breaking"
2205 export GENTOO_COMPILER="javac"
2206 break
2207 fi
2208
2209 if has ${compiler} ${JAVA_PKG_FILTER_COMPILER}; then
2210 if [[ -z ${JAVA_PKG_FORCE_COMPILER} ]]; then
2211 einfo "Filtering ${compiler}"
2212 continue
2213 fi
2214 fi
2215
2216 # for non-javac, we need to make sure it supports the right target and
2217 # source
2218 local compiler_env="${JAVA_PKG_COMPILER_DIR}/${compiler}"
2219 if [[ -f ${compiler_env} ]]; then
2220 local desired_target="$(java-pkg_get-target)"
2221 local desired_source="$(java-pkg_get-source)"
2222
2223
2224 # Verify that the compiler supports target
2225 local supported_target=$(source ${compiler_env} 1>/dev/null 2>&1; echo ${SUPPORTED_TARGET})
2226 if ! has ${desired_target} ${supported_target}; then
2227 ewarn "${compiler} does not support -target ${desired_target}, skipping"
2228 continue
2229 fi
2230
2231 # Verify that the compiler supports source
2232 local supported_source=$(source ${compiler_env} 1>/dev/null 2>&1; echo ${SUPPORTED_SOURCE})
2233 if ! has ${desired_source} ${supported_source}; then
2234 ewarn "${compiler} does not support -source ${desired_source}, skipping"
2235 continue
2236 fi
2237
2238 # if you get here, then the compiler should be good to go
2239 export GENTOO_COMPILER="${compiler}"
2240 break
2241 else
2242 ewarn "Could not find configuration for ${compiler}, skipping"
2243 ewarn "Perhaps it is not installed?"
2244 continue
2245 fi
2246 done
2247
2248 # If it hasn't been defined already, default to javac
2249 if [[ -z ${GENTOO_COMPILER} ]]; then
2250 if [[ -n ${compilers} ]]; then
2251 einfo "No suitable compiler found: defaulting to JDK default for compilation"
2252 else
2253 # probably don't need to notify users about the default.
2254 :;#einfo "Defaulting to javac for compilation"
2255 fi
2256 if java-config -g GENTOO_COMPILER 2> /dev/null; then
2257 export GENTOO_COMPILER=$(java-config -g GENTOO_COMPILER)
2258 else
2259 export GENTOO_COMPILER=javac
2260 fi
2261 else
2262 einfo "Using ${GENTOO_COMPILER} for compilation"
2263 fi
2264
2265 }
2266
2267 # @FUNCTION: init_paths_
2268 # @INTERNAL
2269 # @DESCRIPTION:
2270 # Initializes some variables that will be used. These variables are mostly used
2271 # to determine where things will eventually get installed.
2272 java-pkg_init_paths_() {
2273 debug-print-function ${FUNCNAME} $*
2274
2275 local pkg_name
2276 if [[ "${SLOT%/*}" == "0" ]] ; then
2277 JAVA_PKG_NAME="${PN}"
2278 else
2279 JAVA_PKG_NAME="${PN}-${SLOT%/*}"
2280 fi
2281
2282 JAVA_PKG_SHAREPATH="${DESTTREE}/share/${JAVA_PKG_NAME}"
2283 JAVA_PKG_SOURCESPATH="${JAVA_PKG_SHAREPATH}/sources/"
2284 JAVA_PKG_ENV="${D}${JAVA_PKG_SHAREPATH}/package.env"
2285 JAVA_PKG_VIRTUALS_PATH="${DESTTREE}/share/java-config-2/virtuals"
2286 JAVA_PKG_VIRTUAL_PROVIDER="${D}/${JAVA_PKG_VIRTUALS_PATH}/${JAVA_PKG_NAME}"
2287
2288 [[ -z "${JAVA_PKG_JARDEST}" ]] && JAVA_PKG_JARDEST="${JAVA_PKG_SHAREPATH}/lib"
2289 [[ -z "${JAVA_PKG_LIBDEST}" ]] && JAVA_PKG_LIBDEST="${DESTTREE}/$(get_libdir)/${JAVA_PKG_NAME}"
2290 [[ -z "${JAVA_PKG_WARDEST}" ]] && JAVA_PKG_WARDEST="${JAVA_PKG_SHAREPATH}/webapps"
2291
2292 # TODO maybe only print once?
2293 debug-print "JAVA_PKG_SHAREPATH: ${JAVA_PKG_SHAREPATH}"
2294 debug-print "JAVA_PKG_ENV: ${JAVA_PKG_ENV}"
2295 debug-print "JAVA_PKG_JARDEST: ${JAVA_PKG_JARDEST}"
2296 debug-print "JAVA_PKG_LIBDEST: ${JAVA_PKG_LIBDEST}"
2297 debug-print "JAVA_PKG_WARDEST: ${JAVA_PKG_WARDEST}"
2298 }
2299
2300 # @FUNCTION: java-pkg_do_write_
2301 # @INTERNAL
2302 # @DESCRIPTION:
2303 # Writes the package.env out to disk.
2304 #
2305 # TODO change to do-write, to match everything else
2306 java-pkg_do_write_() {
2307 debug-print-function ${FUNCNAME} $*
2308 java-pkg_init_paths_
2309 # Create directory for package.env
2310 dodir "${JAVA_PKG_SHAREPATH}"
2311 if [[ -n "${JAVA_PKG_CLASSPATH}" || -n "${JAVA_PKG_LIBRARY}" || -f \
2312 "${JAVA_PKG_DEPEND_FILE}" || -f \
2313 "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]]; then
2314 # Create package.env
2315 (
2316 echo "DESCRIPTION=\"${DESCRIPTION}\""
2317 echo "GENERATION=\"2\""
2318 echo "SLOT=\"${SLOT}\""
2319 echo "CATEGORY=\"${CATEGORY}\""
2320 echo "PVR=\"${PVR}\""
2321
2322 [[ -n "${JAVA_PKG_CLASSPATH}" ]] && echo "CLASSPATH=\"${JAVA_PKG_CLASSPATH}\""
2323 [[ -n "${JAVA_PKG_LIBRARY}" ]] && echo "LIBRARY_PATH=\"${JAVA_PKG_LIBRARY}\""
2324 [[ -n "${JAVA_PROVIDE}" ]] && echo "PROVIDES=\"${JAVA_PROVIDE}\""
2325 [[ -f "${JAVA_PKG_DEPEND_FILE}" ]] \
2326 && echo "DEPEND=\"$(sort -u "${JAVA_PKG_DEPEND_FILE}" | tr '\n' ':')\""
2327 [[ -f "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" ]] \
2328 && echo "OPTIONAL_DEPEND=\"$(sort -u "${JAVA_PKG_OPTIONAL_DEPEND_FILE}" | tr '\n' ':')\""
2329 echo "VM=\"$(echo ${RDEPEND} ${DEPEND} | sed -e 's/ /\n/g' | sed -n -e '/virtual\/\(jre\|jdk\)/ { p;q }')\"" # TODO cleanup !
2330 [[ -f "${JAVA_PKG_BUILD_DEPEND_FILE}" ]] \
2331 && echo "BUILD_DEPEND=\"$(sort -u "${JAVA_PKG_BUILD_DEPEND_FILE}" | tr '\n' ':')\""
2332 ) > "${JAVA_PKG_ENV}"
2333
2334 # register target/source
2335 local target="$(java-pkg_get-target)"
2336 local source="$(java-pkg_get-source)"
2337 [[ -n ${target} ]] && echo "TARGET=\"${target}\"" >> "${JAVA_PKG_ENV}"
2338 [[ -n ${source} ]] && echo "SOURCE=\"${source}\"" >> "${JAVA_PKG_ENV}"
2339
2340 # register javadoc info
2341 [[ -n ${JAVADOC_PATH} ]] && echo "JAVADOC_PATH=\"${JAVADOC_PATH}\"" \
2342 >> ${JAVA_PKG_ENV}
2343 # register source archives
2344 [[ -n ${JAVA_SOURCES} ]] && echo "JAVA_SOURCES=\"${JAVA_SOURCES}\"" \
2345 >> ${JAVA_PKG_ENV}
2346
2347
2348 echo "MERGE_VM=\"${GENTOO_VM}\"" >> "${JAVA_PKG_ENV}"
2349 [[ -n ${GENTOO_COMPILER} ]] && echo "MERGE_COMPILER=\"${GENTOO_COMPILER}\"" >> "${JAVA_PKG_ENV}"
2350
2351 # extra env variables
2352 if [[ -n "${JAVA_PKG_EXTRA_ENV_VARS}" ]]; then
2353 cat "${JAVA_PKG_EXTRA_ENV}" >> "${JAVA_PKG_ENV}" || die
2354 # nested echo to remove leading/trailing spaces
2355 echo "ENV_VARS=\"$(echo ${JAVA_PKG_EXTRA_ENV_VARS})\"" \
2356 >> "${JAVA_PKG_ENV}" || die
2357 fi
2358
2359 # Strip unnecessary leading and trailing colons
2360 # TODO try to cleanup if possible
2361 sed -e "s/=\":/=\"/" -e "s/:\"$/\"/" -i "${JAVA_PKG_ENV}" || die "Did you forget to call java_init ?"
2362 else
2363 debug-print "JAVA_PKG_CLASSPATH, JAVA_PKG_LIBRARY, JAVA_PKG_DEPEND_FILE"
2364 debug-print "or JAVA_PKG_OPTIONAL_DEPEND_FILE not defined so can't"
2365 debug-print "write package.env."
2366 fi
2367 }
2368
2369 # @FUNCTION: java-pkg_record-jar_
2370 # @INTERNAL
2371 # @DESCRIPTION:
2372 # Record an (optional) dependency to the package.env
2373 # @CODE
2374 # Parameters:
2375 # --optional - record dependency as optional
2376 # --build - record dependency as build_only
2377 # $1 - package to record
2378 # $2 - (optional) jar of package to record
2379 # @CODE
2380 JAVA_PKG_DEPEND_FILE="${T}/java-pkg-depend"
2381 JAVA_PKG_OPTIONAL_DEPEND_FILE="${T}/java-pkg-optional-depend"
2382 JAVA_PKG_BUILD_DEPEND_FILE="${T}/java-pkg-build-depend"
2383
2384 java-pkg_record-jar_() {
2385 debug-print-function ${FUNCNAME} $*
2386
2387 local depend_file="${JAVA_PKG_DEPEND_FILE}"
2388 case "${1}" in
2389 "--optional") depend_file="${JAVA_PKG_OPTIONAL_DEPEND_FILE}"; shift;;
2390 "--build-only") depend_file="${JAVA_PKG_BUILD_DEPEND_FILE}"; shift;;
2391 esac
2392
2393 local pkg=${1} jar=${2} append
2394 if [[ -z "${jar}" ]]; then
2395 append="${pkg}"
2396 else
2397 append="$(basename ${jar})@${pkg}"
2398 fi
2399
2400 echo "${append}" >> "${depend_file}"
2401 }
2402
2403 # @FUNCTION: java-pkg_append_
2404 # @INTERNAL
2405 # @DESCRIPTION:
2406 # Appends a value to a variable
2407 #
2408 # @CODE
2409 # Parameters:
2410 # $1 variable name to modify
2411 # $2 value to append
2412 #
2413 # Examples:
2414 # java-pkg_append_ CLASSPATH foo.jar
2415 # @CODE
2416 java-pkg_append_() {
2417 debug-print-function ${FUNCNAME} $*
2418
2419 local var="${1}" value="${2}"
2420 if [[ -z "${!var}" ]] ; then
2421 export ${var}="${value}"
2422 else
2423 local oldIFS=${IFS} cur haveit
2424 IFS=':'
2425 for cur in ${!var}; do
2426 if [[ ${cur} == ${value} ]]; then
2427 haveit="yes"
2428 break
2429 fi
2430 done
2431 [[ -z ${haveit} ]] && export ${var}="${!var}:${value}"
2432 IFS=${oldIFS}
2433 fi
2434 }
2435
2436 # @FUNCTION: java-pkg_expand_dir_
2437 # @INTERNAL
2438 # @DESCRIPTION:
2439 # Gets the full path of the file/directory's parent.
2440 # @CODE
2441 # Parameters:
2442 # $1 - file/directory to find parent directory for
2443 # @CODE
2444 # @RETURN: path to $1's parent directory
2445 java-pkg_expand_dir_() {
2446 pushd "$(dirname "${1}")" >/dev/null 2>&1
2447 pwd
2448 popd >/dev/null 2>&1
2449 }
2450
2451 # @FUNCTION: java-pkg_func-exists
2452 # @INTERNAL
2453 # @DESCRIPTION:
2454 # Does the indicated function exist?
2455 # @RETURN: 0 - function is declared, 1 - function is undeclared
2456 java-pkg_func-exists() {
2457 declare -F ${1} > /dev/null
2458 }
2459
2460 # @FUNCTION: java-pkg_setup-vm
2461 # @INTERNAL
2462 # @DESCRIPTION:
2463 # Sets up the environment for a specific VM
2464 java-pkg_setup-vm() {
2465 debug-print-function ${FUNCNAME} $*
2466
2467 local vendor="$(java-pkg_get-vm-vendor)"
2468 if [[ "${vendor}" == "sun" ]] && java-pkg_is-vm-version-ge "1.5" ; then
2469 addpredict "/dev/random"
2470 elif [[ "${vendor}" == "ibm" ]]; then
2471 addpredict "/proc/self/maps"
2472 addpredict "/proc/cpuinfo"
2473 addpredict "/proc/self/coredump_filter"
2474 elif [[ "${vendor}" == "oracle" ]]; then
2475 addpredict "/dev/random"
2476 addpredict "/proc/self/coredump_filter"
2477 elif [[ "${vendor}" == icedtea* ]] && java-pkg_is-vm-version-ge "1.7" ; then
2478 addpredict "/dev/random"
2479 addpredict "/proc/self/coredump_filter"
2480 elif [[ "${vendor}" == "jrockit" ]]; then
2481 addpredict "/proc/cpuinfo"
2482 fi
2483 }
2484
2485 # @FUNCTION: java-pkg_needs-vm
2486 # @INTERNAL
2487 # @DESCRIPTION:
2488 # Does the current package depend on virtual/jdk or does it set
2489 # JAVA_PKG_WANT_BUILD_VM?
2490 #
2491 # @RETURN: 0 - Package depends on virtual/jdk; 1 - Package does not depend on virtual/jdk
2492 java-pkg_needs-vm() {
2493 debug-print-function ${FUNCNAME} $*
2494
2495 if [[ -n "$(echo ${JAVA_PKG_NV_DEPEND:-${DEPEND}} | sed -e '\:virtual/jdk:!d')" ]]; then
2496 return 0
2497 fi
2498
2499 [[ -n "${JAVA_PKG_WANT_BUILD_VM}" ]] && return 0
2500
2501 return 1
2502 }
2503
2504 # @FUNCTION: java-pkg_get-current-vm
2505 # @INTERNAL
2506 # @RETURN - The current VM being used
2507 java-pkg_get-current-vm() {
2508 java-config -f
2509 }
2510
2511 # @FUNCTION: java-pkg_get-vm-vendor
2512 # @INTERNAL
2513 # @RETURN - The vendor of the current VM
2514 java-pkg_get-vm-vendor() {
2515 debug-print-function ${FUNCNAME} $*
2516
2517 local vm="$(java-pkg_get-current-vm)"
2518 vm="${vm/-*/}"
2519 echo "${vm}"
2520 }
2521
2522 # @FUNCTION: java-pkg_get-vm-version
2523 # @INTERNAL
2524 # @RETURN - The version of the current VM
2525 java-pkg_get-vm-version() {
2526 debug-print-function ${FUNCNAME} $*
2527
2528 java-config -g PROVIDES_VERSION
2529 }
2530
2531 # @FUNCTION: java-pkg_build-vm-from-handle
2532 # @INTERNAL
2533 # @DESCRIPTION:
2534 # Selects a build vm from a list of vm handles. First checks for the system-vm
2535 # beeing usable, then steps through the listed handles till a suitable vm is
2536 # found.
2537 #
2538 # @RETURN - VM handle of an available JDK
2539 java-pkg_build-vm-from-handle() {
2540 debug-print-function ${FUNCNAME} "$*"
2541
2542 local vm
2543 vm=$(java-pkg_get-current-vm 2>/dev/null)
2544 if [[ $? -eq 0 ]]; then
2545 if has ${vm} ${JAVA_PKG_WANT_BUILD_VM}; then
2546 echo ${vm}
2547 return 0
2548 fi
2549 fi
2550
2551 for vm in ${JAVA_PKG_WANT_BUILD_VM}; do
2552 if java-config-2 --select-vm=${vm} 2>/dev/null; then
2553 echo ${vm}
2554 return 0
2555 fi
2556 done
2557
2558 eerror "${FUNCNAME}: No vm found for handles: ${JAVA_PKG_WANT_BUILD_VM}"
2559 return 1
2560 }
2561
2562 # @FUNCTION: java-pkg_switch-vm
2563 # @INTERNAL
2564 # @DESCRIPTION:
2565 # Switch VM if we're allowed to (controlled by JAVA_PKG_ALLOW_VM_CHANGE), and
2566 # verify that the current VM is sufficient.
2567 # Setup the environment for the VM being used.
2568 java-pkg_switch-vm() {
2569 debug-print-function ${FUNCNAME} $*
2570
2571 if java-pkg_needs-vm; then
2572 # Use the VM specified by JAVA_PKG_FORCE_VM
2573 if [[ -n "${JAVA_PKG_FORCE_VM}" ]]; then
2574 # If you're forcing the VM, I hope you know what your doing...
2575 debug-print "JAVA_PKG_FORCE_VM used: ${JAVA_PKG_FORCE_VM}"
2576 export GENTOO_VM="${JAVA_PKG_FORCE_VM}"
2577 # if we're allowed to switch the vm...
2578 elif [[ "${JAVA_PKG_ALLOW_VM_CHANGE}" == "yes" ]]; then
2579 # if there is an explicit list of handles to choose from
2580 if [[ -n "${JAVA_PKG_WANT_BUILD_VM}" ]]; then
2581 debug-print "JAVA_PKG_WANT_BUILD_VM used: ${JAVA_PKG_WANT_BUILD_VM}"
2582 GENTOO_VM=$(java-pkg_build-vm-from-handle)
2583 if [[ $? != 0 ]]; then
2584 eerror "${FUNCNAME}: No VM found for handles: ${JAVA_PKG_WANT_BUILD_VM}"
2585 die "${FUNCNAME}: Failed to determine VM for building"
2586 fi
2587 # JAVA_PKG_WANT_SOURCE and JAVA_PKG_WANT_TARGET are required as
2588 # they can't be deduced from handles.
2589 if [[ -z "${JAVA_PKG_WANT_SOURCE}" ]]; then
2590 eerror "JAVA_PKG_WANT_BUILD_VM specified but not JAVA_PKG_WANT_SOURCE"
2591 die "Specify JAVA_PKG_WANT_SOURCE"
2592 fi
2593 if [[ -z "${JAVA_PKG_WANT_TARGET}" ]]; then
2594 eerror "JAVA_PKG_WANT_BUILD_VM specified but not JAVA_PKG_WANT_TARGET"
2595 die "Specify JAVA_PKG_WANT_TARGET"
2596 fi
2597 # otherwise determine a vm from dep string
2598 else
2599 debug-print "depend-java-query: NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2600 GENTOO_VM="$(depend-java-query --get-vm "${JAVA_PKG_NV_DEPEND:-${DEPEND}}")"
2601 if [[ -z "${GENTOO_VM}" || "${GENTOO_VM}" == "None" ]]; then
2602 eerror "Unable to determine VM for building from dependencies:"
2603 echo "NV_DEPEND: ${JAVA_PKG_NV_DEPEND:-${DEPEND}}"
2604 die "Failed to determine VM for building."
2605 fi
2606 fi
2607 export GENTOO_VM
2608 # otherwise just make sure the current VM is sufficient
2609 else
2610 java-pkg_ensure-vm-version-sufficient
2611 fi
2612 debug-print "Using: $(java-config -f)"
2613
2614 java-pkg_setup-vm
2615
2616 export JAVA=$(java-config --java)
2617 export JAVAC=$(java-config --javac)
2618 JAVACFLAGS="$(java-pkg_javac-args)"
2619 if [[ ${?} != 0 ]]; then
2620 eerror "There was a problem determining JAVACFLAGS: ${JAVACFLAGS}"
2621 die "java-pkg_javac-args failed"
2622 fi
2623 [[ -n ${JAVACFLAGS_EXTRA} ]] && JAVACFLAGS="${JAVACFLAGS_EXTRA} ${JAVACFLAGS}"
2624 export JAVACFLAGS
2625
2626 export JAVA_HOME="$(java-config -g JAVA_HOME)"
2627 export JDK_HOME=${JAVA_HOME}
2628
2629 #TODO If you know a better solution let us know.
2630 java-pkg_append_ LD_LIBRARY_PATH "$(java-config -g LDPATH)"
2631
2632 local tann="${T}/announced-vm"
2633 # With the hooks we should only get here once from pkg_setup but better safe than sorry
2634 # if people have for example modified eclasses some where
2635 if [[ -n "${JAVA_PKG_DEBUG}" ]] || [[ ! -f "${tann}" ]] ; then
2636 einfo "Using: $(java-config -f)"
2637 [[ ! -f "${tann}" ]] && touch "${tann}"
2638 fi
2639
2640 else
2641 [[ -n "${JAVA_PKG_DEBUG}" ]] && ewarn "!!! This package inherits java-pkg but doesn't depend on a JDK. -bin or broken dependency!!!"
2642 fi
2643 }
2644
2645 # @FUNCTION: java-pkg_die
2646 # @INTERNAL
2647 # @DESCRIPTION:
2648 # Enhanced die for Java packages, which displays some information that may be
2649 # useful for debugging bugs on bugzilla.
2650 #register_die_hook java-pkg_die
2651 if ! has java-pkg_die ${EBUILD_DEATH_HOOKS}; then
2652 EBUILD_DEATH_HOOKS="${EBUILD_DEATH_HOOKS} java-pkg_die"
2653 fi
2654
2655 java-pkg_die() {
2656 echo "!!! When you file a bug report, please include the following information:" >&2
2657 echo "GENTOO_VM=${GENTOO_VM} CLASSPATH=\"${CLASSPATH}\" JAVA_HOME=\"${JAVA_HOME}\"" >&2
2658 echo "JAVACFLAGS=\"${JAVACFLAGS}\" COMPILER=\"${GENTOO_COMPILER}\"" >&2
2659 echo "and of course, the output of emerge --info =${P}" >&2
2660 }
2661
2662
2663 # TODO document
2664 # List jars in the source directory, ${S}
2665 java-pkg_jar-list() {
2666 if [[ -n "${JAVA_PKG_DEBUG}" ]]; then
2667 einfo "Linked Jars"
2668 find "${S}" -type l -name '*.jar' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2669 einfo "Jars"
2670 find "${S}" -type f -name '*.jar' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2671 einfo "Classes"
2672 find "${S}" -type f -name '*.class' -print0 | xargs -0 -r -n 500 ls -ald | sed -e "s,${WORKDIR},\${WORKDIR},"
2673 fi
2674 }
2675
2676 # @FUNCTION: java-pkg_verify-classes
2677 # @INTERNAL
2678 # @DESCRIPTION:
2679 # Verify that the classes were compiled for the right source / target. Dies if
2680 # not.
2681 # @CODE
2682 # $1 (optional) - the file to check, otherwise checks whole ${D}
2683 # @CODE
2684 java-pkg_verify-classes() {
2685 #$(find ${D} -type f -name '*.jar' -o -name '*.class')
2686
2687 local version_verify="/usr/bin/class-version-verify.py"
2688
2689 if [[ ! -x "${version_verify}" ]]; then
2690 version_verify="/usr/$(get_libdir)/javatoolkit/bin/class-version-verify.py"
2691 fi
2692
2693 if [[ ! -x "${version_verify}" ]]; then
2694 ewarn "Unable to perform class version checks as"
2695 ewarn "class-version-verify.py is unavailable"
2696 ewarn "Please install dev-java/javatoolkit."
2697 return
2698 fi
2699
2700 local target=$(java-pkg_get-target)
2701 local result
2702 local log="${T}/class-version-verify.log"
2703 if [[ -n "${1}" ]]; then
2704 ${version_verify} -v -t ${target} "${1}" > "${log}"
2705 result=$?
2706 else
2707 ebegin "Verifying java class versions (target: ${target})"
2708 ${version_verify} -v -t ${target} -r "${D}" > "${log}"
2709 result=$?
2710 eend ${result}
2711 fi
2712 [[ -n ${JAVA_PKG_DEBUG} ]] && cat "${log}"
2713 if [[ ${result} != 0 ]]; then
2714 eerror "Incorrect bytecode version found"
2715 [[ -n "${1}" ]] && eerror "in file: ${1}"
2716 eerror "See ${log} for more details."
2717 die "Incorrect bytecode found"
2718 fi
2719 }
2720
2721 # @FUNCTION: java-pkg_ensure-dep
2722 # @INTERNAL
2723 # @DESCRIPTION:
2724 # Check that a package being used in jarfrom, getjars and getjar is contained
2725 # within DEPEND or RDEPEND with the correct SLOT. See this mail for details:
2726 # https://archives.gentoo.org/gentoo-dev/message/dcb644f89520f4bbb61cc7bbe45fdf6e
2727 # @CODE
2728 # Parameters:
2729 # $1 - empty - check both vars; "runtime" or "build" - check only
2730 # RDEPEND, resp. DEPEND
2731 # $2 - Package name and slot.
2732 # @CODE
2733 java-pkg_ensure-dep() {
2734 debug-print-function ${FUNCNAME} $*
2735
2736 local limit_to="${1}"
2737 local target_pkg="${2}"
2738 local dev_error=""
2739
2740 # Transform into a regular expression to look for a matching package
2741 # and SLOT. SLOTs don't have to be numeric so foo-bar could either
2742 # mean foo-bar:0 or foo:bar. So you want to get your head around the
2743 # line below?
2744 #
2745 # * The target package first has any dots escaped, e.g. foo-1.2
2746 # becomes foo-1\.2.
2747 #
2748 # * sed then looks at the component following the last - or :
2749 # character, or the whole string if there is no - or :
2750 # character. It uses this to build a new regexp with two
2751 # significant branches.
2752 #
2753 # * The first checks for the whole target package string, optionally
2754 # followed by a version number, and then :0.
2755 #
2756 # * The second checks for the first part of the target package
2757 # string, optionally followed by a version number, followed by the
2758 # aforementioned component, treating that as a SLOT.
2759 #
2760 local stripped_pkg=/$(sed -r 's/[-:]?([^-:]+)$/(\0(-[^:]+)?:0|(-[^:]+)?:\1)/' <<< "${target_pkg//./\\.}")\\b
2761
2762 debug-print "Matching against: ${stripped_pkg}"
2763
2764 # Uncomment the lines below once we've dealt with more of these
2765 # otherwise we'll be tempted to turn JAVA_PKG_STRICT off while
2766 # getting hit with a wave of bug reports. :(
2767
2768 if [[ ${limit_to} != runtime && ! ( "${DEPEND}" =~ $stripped_pkg ) ]]; then
2769 dev_error="The ebuild is attempting to use ${target_pkg}, which is not "
2770 dev_error+="declared with a SLOT in DEPEND."
2771 # if is-java-strict; then
2772 # die "${dev_error}"
2773 # else
2774 eqawarn "java-pkg_ensure-dep: ${dev_error}"
2775 # eerror "Because you have ${target_pkg} installed,"
2776 # eerror "the package will build without problems, but please"
2777 # eerror "report this to http://bugs.gentoo.org."
2778 # fi
2779 elif [[ ${limit_to} != build && ! ( "${RDEPEND}${PDEPEND}" =~ ${stripped_pkg} ) ]]; then
2780 dev_error="The ebuild is attempting to use ${target_pkg}, which is not "
2781 dev_error+="declared with a SLOT in [RP]DEPEND and --build-only wasn't given."
2782 # if is-java-strict; then
2783 # die "${dev_error}"
2784 # else
2785 eqawarn "java-pkg_ensure-dep: ${dev_error}"
2786 # eerror "The package will build without problems, but may fail to run"
2787 # eerror "if you don't have ${target_pkg} installed,"
2788 # eerror "so please report this to http://bugs.gentoo.org."
2789 # fi
2790 fi
2791 }
2792
2793 java-pkg_check-phase() {
2794 local phase=${1}
2795 local funcname=${FUNCNAME[1]}
2796 if [[ ${EBUILD_PHASE} != ${phase} ]]; then
2797 local msg="${funcname} used outside of src_${phase}"
2798 java-pkg_announce-qa-violation "${msg}"
2799 fi
2800 }
2801
2802 java-pkg_check-versioned-jar() {
2803 local jar=${1}
2804
2805 if [[ ${jar} =~ ${PV} ]]; then
2806 java-pkg_announce-qa-violation "installing versioned jar '${jar}'"
2807 fi
2808 }
2809
2810 java-pkg_check-jikes() {
2811 if has jikes ${IUSE}; then
2812 java-pkg_announce-qa-violation "deprecated USE flag 'jikes' in IUSE"
2813 fi
2814 }
2815
2816 java-pkg_announce-qa-violation() {
2817 local nodie
2818 if [[ ${1} == "--nodie" ]]; then
2819 nodie="true"
2820 shift
2821 fi
2822 echo "Java QA Notice: $@" >&2
2823 increment-qa-violations
2824 [[ -z "${nodie}" ]] && is-java-strict && die "${@}"
2825 }
2826
2827 increment-qa-violations() {
2828 let "JAVA_PKG_QA_VIOLATIONS+=1"
2829 export JAVA_PKG_QA_VIOLATIONS
2830 }
2831
2832 is-java-strict() {
2833 [[ -n ${JAVA_PKG_STRICT} ]]
2834 return $?
2835 }

  ViewVC Help
Powered by ViewVC 1.1.20