Introduction à OpenJDK
OpenJDK est une implémentation
libre de la plateforme d'édition standard Java d'Oracle.
OpenJDK est utile pour développer
des programmes Java, et fournir un
environnement d'exécution complet pour lancer des programmes
Java.
This package is known to build and work properly using an LFS-7.10
platform.
![[Note]](../images/note.png)
Note
Un greffon de navigateur et une implémentation de webstart, aussi
bien qu'un moteur de sons utilisant pulseaudio sont fournis par
le projet Icedtea. Pour fournir une implémentation complète, vous
devrez installer plus tard IcedTea-Web-1.6.2 et IcedTea-Sound-1.0.1.
OpenJDK est sous GPL, cependant, il convient de préciser qu'il y a
eu une exception spéciale pour les projets non-libres d'utiliser
ces classes dans leurs produits propriétaires. De façon similaire à
la LGPL, qui autorise des programmes non-libre à lier des
bibliothèques fournit par des programmes libres, La GNU
General Public License, version 2, avec l'exception des chemins de
classe autorise des programmes tiers à utiliser des classes
fournies par des programmes libres sans l'obligation que le
programme tiers soit également libre. Comme avec la LGPL, toutes
les modifications faites dans des parties d'un programme libre
d'une application tierce, doit également être librement disponible.
Note
Les sources de OpenJDK incluent
une suite de tests très complète et open source appelée
JTreg. Les instructions de tests
suivantes permettent de tester le JDK tout juste construit pour
une compatibilité raisonnable avec le JDK fermé d'Oracle.
Cependant, pour qu'une implémentation indépendante revendique la
compatibilité, elle doit passer une suite de tests fermée
JCK/TCK. Aucune revendication de
compatibilité, même une compatibilité partielle, peut être faite
sans passer une suite de tests approuvée.
Oracle fournit un accès libre communautaire, au cas par cas, à
des outils fermés pour assurer une compatibilité à 100% avec leur
JDK propriétaire. Cependant la version binaire fournie sur la
page Java-1.8.0.102 comme la JVM construit avec
les instructions suivantes n'ont pas été testées avec
TCK. Aucune version qui seraient construites en utilisant les
instructions données, ne pourra revendiquer d'être compatible
avec le JDK propriétaire, sans que l'utilisateur demande, et
réussisse les tests de compatibilités.
Avec cela en tête, les binaires produits en utilisant cette
méthode de construction sont régulièrement testé avec le TCK par
les membres listés sur le site au dessus. En supplément de la
licence communautaire, une licence pour l'éducation,
non-commerciale pour TCK peut être obtenue ici.
Information sur le paquet source
-
Paquet des sources OpenJDK
Téléchargement :
http://hg.openjdk.java.net/jdk8u/jdk8u/archive/jdk8u102-b14.tar.bz2
Somme de contrôle MD5 du téléchargement :
04ecdce899eb3d6de9d5aadc438998c0
Taille de téléchargement : 400 Ko
-
En plus du paquet principal, les instructions suivantes
commecent par télécharger sept archives de sous-projet, pour
une taille totale de 63 Mo.
-
Estimation de l'espace disque requis : 3.5 Go (410 Mo
supplémentaires pour les tests)
-
Estimation du temps de construction : 4 SBU avec 4
tâches en parallèle (63 SBU supplémentaires pour les tests)
Téléchargements supplémentaires
Dépendances de OpenJDK
Dépendances de Required
Un binaire existant (Java-1.8.0.102 ou une version construite
récente de ce paquet. Les instructions qui suivent considèrent que
vous utilisez Configuration de
l'environnement JAVA) alsa-lib-1.1.2, cpio-2.12, Cups-2.1.4, UnZip-6.0, Which-2.21, Bibliothèques Xorg
et Zip-3.0.
Recommandées
Certificats d'autorité de
certification, giflib-5.1.4 et Wget-1.18
Facultatives
Mercurial-3.9 et un gestionnaire de fenêtres X
comme twm-1.0.9 (pour les tests)
Notes utilisateur : http://wiki.linuxfromscratch.org/blfs/wiki/openjdk
Installation de OpenJDK
Contrairement aux autres paquets dans BLFS, les sources de
OpenJDK sont distribuées dans de
multiples téléchargements. Vous devez commencer par extraire les
sources racines depuis le fichier jdk8u102-b14.tar.bz2. Allez dans le répertoire
extrait, puis continuez avec les instruction suivantes :
cat > subprojects.md5 << EOF &&
6ea4a074a80d0ee4b6dcd50398835c49 corba.tar.bz2
27b9e7e94fc6a47f452e8a94ba156395 hotspot.tar.bz2
da82a91df3eb4c98ebaab4e71cbbcc4d jaxp.tar.bz2
8a91561bbc04f50a92032d82b78960e0 jaxws.tar.bz2
61c645dbacfb925944f716ec50474821 langtools.tar.bz2
e65f6d029808a8b523e07d818c8ac9ad jdk.tar.bz2
2c981235c1cbaba58197fd9b7ffd00e1 nashorn.tar.bz2
EOF
for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
wget -c http://hg.openjdk.java.net/jdk8u/jdk8u/${subproject}/archive/jdk8u102-b14.tar.bz2 \
-O ${subproject}.tar.bz2
done &&
md5sum -c subprojects.md5 &&
for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
mkdir -pv ${subproject} &&
tar -xf ${subproject}.tar.bz2 --strip-components=1 -C ${subproject}
done
Si vous avez téléchargé la suite de tests facultative, décompressez
la également :
tar -xf ../jtreg-4.2-b03-639.tar.gz
Note
Avant de continuer, vous devez vous assurer que votre variable
d'environnement PATH contient le
dossier du compilateur Java utilisé pour boostrapper OpenJDK. C'est le seul impératif pour
l'environnement. Les installations modernes de Java n'ont pas
besoin de JAVA_HOME et CLASSPATH n'est pas utilisé ici. De plus les
développeurs d'OpenJDK recommandent de ne pas initialiser
JAVA_HOME.
Le système de construction ne supporte pas le paramètre
-j dans MAKEFLAGS.
Configurez et construisez le paquet avec les commandes suivantes
(la valeur --with-milestone peut être modifiée selon les
préférences de l'utilisateur) :
unset JAVA_HOME &&
sh ./configure \
--with-update-version=102 \
--with-build-number=b14 \
--with-milestone=BLFS \
--enable-unlimited-crypto \
--with-zlib=system \
--with-giflib=system \
--with-extra-cflags="-std=c++98 -Wno-error -fno-delete-null-pointer-checks -fno-lifetime-dse" \
--with-extra-cxxflags="-std=c++98 -fno-delete-null-pointer-checks -fno-lifetime-dse" &&
make DEBUG_BINARIES=true SCTP_WERROR= all &&
find build/*/images/j2sdk-image -iname \*.diz -delete
Note
Les tests impliqueront des communications entre paires de JVM en
utilisant des interfaces réseaux, donc le réseau doit être
démarré. Sinon, non seulement ces tests échoueront, mais le
nettoyage des tests laissera des JVM orphelines lancées. Il y en
aura beaucoup. Redémarrer peut être la solution la plus simple.
Tester la nouvelle version construite de la JVM implique quelques
étapes. En premier, il vaut mieux lancer la suite de test dans un
framebuffer sur un affichage différent, en utilisant Xvfb :
if [ -n "$DISPLAY" ]; then
OLD_DISP=$DISPLAY
fi
export DISPLAY=:20
nohup Xvfb $DISPLAY \
-fbdir $(pwd) \
-pixdepths 8 16 24 32 > Xvfb.out 2>&1 &
echo $! > Xvfb.pid
echo Waiting for Xvfb to initialize; sleep 1
nohup twm -display $DISPLAY \
-f /dev/null > twm.out 2>&1 &
echo $! > twm.pid
echo Waiting for twm to initialize; sleep 1
xhost +
Ensuite, il est nécessaire de modifier quelques fichiers :
echo -e "
jdk_all = :jdk_core \\
:jdk_svc \\
:jdk_beans \\
:jdk_imageio \\
:jdk_sound \\
:jdk_sctp \\
com/sun/awt \\
javax/accessibility \\
javax/print \\
sun/pisces \\
com/sun/java/swing" >> jdk/test/TEST.groups &&
sed -e 's/all:.*jck.*/all: jtreg/' \
-e '/^JTREG /s@\$(JT_PLATFORM)/@@' \
-i langtools/test/Makefile
Quelques variables doivent être initialisée :
JT_JAVA=$(type -p javac | sed 's@/bin.*@@') &&
JT_HOME=$(pwd)/jtreg &&
PRODUCT_HOME=$(echo $(pwd)/build/*/images/j2sdk-image)
Les tests sont lancés comme ceci :
LANG=C make -k -C test \
JT_HOME=${JT_HOME} \
JT_JAVA=${JT_JAVA} \
PRODUCT_HOME=${PRODUCT_HOME} all
LANG=C ${JT_HOME}/bin/jtreg -a -v:fail,error \
-dir:$(pwd)/hotspot/test \
-k:\!ignore \
-jdk:${PRODUCT_HOME} \
:jdk
Les résultats des tests peuvent être comparés avec ces résultats,
bien qu'ils soient lancés sur une nouvelle version. Quelques échecs
peuvent être rencontrés, le nombre dépend de nombreuses conditions,
comme si l'ordinateur est connecté sur un résau. Aussi, certains
tests peuvent dépasser le temps si la machine est chargée. Ce sont
des raisons de considérer les tests comme facultatifs, bien que
nous recommandions de les lancer.
Ensuite quelques nettoyages doivent être faits. Les instructions
suivantes arrêtent seulement le framebuffer, mais il a été signalé
que quelques VM java peuvent rester lancées après les tests, il est
donc nécessaire de vérifier les processus orphelins.
kill -9 `cat twm.pid` &&
kill -9 `cat Xvfb.pid` &&
rm -f Xvfb.out twm.out &&
rm -f Xvfb.pid twm.pid &&
if [ -n "$OLD_DISP" ]; then
DISPLAY=$OLD_DISP
fi
Installez le paquet avec les commandes suivantes en tant
qu'utilisateur root :
cp -RT build/*/images/j2sdk-image /opt/OpenJDK-1.8.0.102 &&
chown -R root:root /opt/OpenJDK-1.8.0.102
Il y a maintenant deux SDK d'OpenJDK installés dans /opt. Vous pouvez décider de laquelle vous voulez
utiliser par défaut. Normalement, vous devez opter pour la version
OpenJDK que vous venez
d'installer. Dans ce cas, exécutez la ligne suivante en tant
qu'utilisateur root :
ln -v -nsf OpenJDK-1.8.0.102 /opt/jdk
Si vous le souhaitez, vous pouvez installer un fichier .desktop
correspondant à une entrée dans le menu du bureau pour policytool. D'abord, vous devez
obtenir un icône de IcedTea-Web-1.6.2 :
tar -xf ../icedtea-web-1.6.2.tar.gz \
icedtea-web-1.6.2/javaws.png \
--strip-components=1
Maintenant, en tant qu'utilisateur root :
mkdir -pv /usr/share/applications &&
cat > /usr/share/applications/openjdk-8-policytool.desktop << "EOF" &&
[Desktop Entry]
Name=OpenJDK Java Policy Tool
Name[pt_BR]=OpenJDK Java - Ferramenta de Política
Comment=OpenJDK Java Policy Tool
Comment[pt_BR]=OpenJDK Java - Ferramenta de Política
Exec=/opt/jdk/bin/policytool
Terminal=false
Type=Application
Icon=javaws
Categories=Settings;
EOF
install -v -Dm0644 javaws.png /usr/share/pixmaps/javaws.png
Le choix de pt_BR est juste un exemple. Vous pouvez ajouter des
traductions en ajoutant les lignes correspondantes à votre locale,
par exemple fr_FR, avec les valeurs « Name[fr_FR]= » et « Comment[fr_FR]= » appropriées pour la langue.
Explication des commandes
sh
configure... : Le niveau supérieur de
configure est une enveloppe pour
autotools. Ce n'est pas un exécutable et il doit être lancé avec
sh.
--with-boot-jdk : Ce paramètre
fournit l'emplacement du JDK
temporaire. Ce n'est normalement pas nécessaire si java est trouvé dans le
PATH.
--with-update-version :
Actuellement, le système de construction n'inclut pas le numéro de
mise à jour dans la chaîne de version. Il est spécifié ici.
--with-build-number :
De nouveau, le système de construction n'inclut pas le numéro de
construction dans la chaîne de version. Il est spécifié ici
également.
--with-milestone :
Utilisé pour personnaliser la chaîne de version.
--enable-unlimited-crypto : À
cause des limitations de l'usage de la cryptographie dans certains
pays, on peut limiter la taille des clés de cryptographie et
l'utilisation de certains algorithmes dans un fichier de politique.
Ce paramètre permet de garder un fichier de politique sans
restriction. Il est de la responsabilité de l'utilisateur de
s'assurer du bon respect de la loi.
--with-zlib=system,
--with-giflib=system : Permet d'utiliser les
bibliothèques du système au lieu de celles livrées.
--with-extra-cflags=...
--with-extra-cxxflags=... : Contourne certains
défauts dans le code mis en lumière par la vérification plus
rigoureuse de GCC 6 dans les constructions C/C++. Supprimez ces
paramètres si vous compilez avec GCC 5.
--with-jobs=N : Permet
d'initialiser le nombre de travaux pour make à N. Par défaut, il s'agit
du résultat du calcul prenant en compte la mémoire disponible et le
nombre de processeurs. Notez que même si vous spécifiez N=1,
certaines parallélisations peuvent être utilisées pendant la
construction. Les SBU sont donnés pour N=4, sur une machine
virtuelle avec un simple processeur, 4 cœurs et 4 Go de mémoire.
--with-cacerts-file=... : Spécifie
où trouver un fichier cacerts,
typiquement /opt/jdk/jre/lib/security. Sinon, un fichier vide
est créé. Vous pouvez l'avoir eu avec une précédente version du
paquet, ou utiliser le script suivant pour le générer.
make DEBUG_BINARIES=true SCTP_WERROR=
all : La construction échoue sur les machines
32 bits si DEBUG_BINARIES n'est pas initialisé à true. Rendre
indéfini SCTP_WERROR fait partie du contournement pour utiliser GCC
6. Vous pouvez omettre cette partie de la commande si vous utilisez
GCC 5.
find ... -iname '*.diz'
-delete : Cette commande supprime les fichiers
redondants.
Configuration de
OpenJDK
Information de configuration
Normalement, l'environnement JAVA a été configuré après
l'installation de la version binaire, et peut être utilisé avec
le paquet fraîchement construit. Regardez Configuration de
l'environnement JAVA dans le cas où vous voudriez modifier
quelque chose.
Pour tester que les pages de manuel sont correctement installées,
tapez source
/etc/profile et man
java pour afficher les pages de manuel
respectives.
Installez ou mettez à
jour les fichiers "Certificats d'autorité de certification pour
JRE" (cacerts)
OpenJDK utilise son propre
format pour les certificats CA. Ces certificats sont placés dans
un fichier nommé /opt/jdk/jre/lib/security/cacerts. Ce fichier
peut être généré depuis un fichier installé en utilisant les
instructions de la page Certificats d'autorité
de certification, en utilisant la procédure suivante.
Commencez par générer le script mkcacerts en tant
qu'utilisateur root :
cat > /opt/jdk/bin/mkcacerts << "EOF"
#!/bin/sh
# Simple script to extract x509 certificates and create a JRE cacerts file.
function get_args()
{
if test -z "${1}" ; then
showhelp
exit 1
fi
while test -n "${1}" ; do
case "${1}" in
-f | --cafile)
check_arg $1 $2
CAFILE="${2}"
shift 2
;;
-d | --cadir)
check_arg $1 $2
CADIR="${2}"
shift 2
;;
-o | --outfile)
check_arg $1 $2
OUTFILE="${2}"
shift 2
;;
-k | --keytool)
check_arg $1 $2
KEYTOOL="${2}"
shift 2
;;
-s | --openssl)
check_arg $1 $2
OPENSSL="${2}"
shift 2
;;
-h | --help)
showhelp
exit 0
;;
*)
showhelp
exit 1
;;
esac
done
}
function check_arg()
{
echo "${2}" | grep -v "^-" > /dev/null
if [ -z "$?" -o ! -n "$2" ]; then
echo "Error: $1 requires a valid argument."
exit 1
fi
}
# The date binary is not reliable on 32bit systems for dates after 2038
function mydate()
{
local y=$( echo $1 | cut -d" " -f4 )
local M=$( echo $1 | cut -d" " -f1 )
local d=$( echo $1 | cut -d" " -f2 )
local m
if [ ${d} -lt 10 ]; then d="0${d}"; fi
case $M in
Jan) m="01";;
Feb) m="02";;
Mar) m="03";;
Apr) m="04";;
May) m="05";;
Jun) m="06";;
Jul) m="07";;
Aug) m="08";;
Sep) m="09";;
Oct) m="10";;
Nov) m="11";;
Dec) m="12";;
esac
certdate="${y}${m}${d}"
}
function showhelp()
{
echo "`basename ${0}` creates a valid cacerts file for use with IcedTea."
echo ""
echo " -f --cafile The path to a file containing PEM"
echo " formated CA certificates. May not be"
echo " used with -d/--cadir."
echo ""
echo " -d --cadir The path to a directory of PEM formatted"
echo " CA certificates. May not be used with"
echo " -f/--cafile."
echo ""
echo " -o --outfile The path to the output file."
echo ""
echo " -k --keytool The path to the java keytool utility."
echo ""
echo " -s --openssl The path to the openssl utility."
echo ""
echo " -h --help Show this help message and exit."
echo ""
echo ""
}
# Initialize empty variables so that the shell does not pollute the script
CAFILE=""
CADIR=""
OUTFILE=""
OPENSSL=""
KEYTOOL=""
certdate=""
date=""
today=$( date +%Y%m%d )
# Process command line arguments
get_args ${@}
# Handle common errors
if test "${CAFILE}x" == "x" -a "${CADIR}x" == "x" ; then
echo "ERROR! You must provide an x509 certificate store!"
echo "\'$(basename ${0}) --help\' for more info."
echo ""
exit 1
fi
if test "${CAFILE}x" != "x" -a "${CADIR}x" != "x" ; then
echo "ERROR! You cannot provide two x509 certificate stores!"
echo "\'$(basename ${0}) --help\' for more info."
echo ""
exit 1
fi
if test "${KEYTOOL}x" == "x" ; then
echo "ERROR! You must provide a valid keytool program!"
echo "\'$(basename ${0}) --help\' for more info."
echo ""
exit 1
fi
if test "${OPENSSL}x" == "x" ; then
echo "ERROR! You must provide a valid path to openssl!"
echo "\'$(basename ${0}) --help\' for more info."
echo ""
exit 1
fi
if test "${OUTFILE}x" == "x" ; then
echo "ERROR! You must provide a valid output file!"
echo "\'$(basename ${0}) --help\' for more info."
echo ""
exit 1
fi
# Get on with the work
# If using a CAFILE, split it into individual files in a temp directory
if test "${CAFILE}x" != "x" ; then
TEMPDIR=`mktemp -d`
CADIR="${TEMPDIR}"
# Get a list of staring lines for each cert
CERTLIST=`grep -n "^-----BEGIN" "${CAFILE}" | cut -d ":" -f 1`
# Get a list of ending lines for each cert
ENDCERTLIST=`grep -n "^-----END" "${CAFILE}" | cut -d ":" -f 1`
# Start a loop
for certbegin in `echo "${CERTLIST}"` ; do
for certend in `echo "${ENDCERTLIST}"` ; do
if test "${certend}" -gt "${certbegin}"; then
break
fi
done
sed -n "${certbegin},${certend}p" "${CAFILE}" > "${CADIR}/${certbegin}.pem"
keyhash=`${OPENSSL} x509 -noout -in "${CADIR}/${certbegin}.pem" -hash`
echo "Generated PEM file with hash: ${keyhash}."
done
fi
# Write the output file
for cert in `find "${CADIR}" -type f -name "*.pem" -o -name "*.crt"`
do
# Make sure the certificate date is valid...
date=$( ${OPENSSL} x509 -enddate -in "${cert}" -noout | sed 's/^notAfter=//' )
mydate "${date}"
if test "${certdate}" -lt "${today}" ; then
echo "${cert} expired on ${certdate}! Skipping..."
unset date certdate
continue
fi
unset date certdate
ls "${cert}"
tempfile=`mktemp`
certbegin=`grep -n "^-----BEGIN" "${cert}" | cut -d ":" -f 1`
certend=`grep -n "^-----END" "${cert}" | cut -d ":" -f 1`
sed -n "${certbegin},${certend}p" "${cert}" > "${tempfile}"
echo yes | env LC_ALL=C "${KEYTOOL}" -import \
-alias `basename "${cert}"` \
-keystore "${OUTFILE}" \
-storepass 'changeit' \
-file "${tempfile}"
rm "${tempfile}"
done
if test "${TEMPDIR}x" != "x" ; then
rm -rf "${TEMPDIR}"
fi
exit 0
EOF
chmod -c 0755 /opt/jdk/bin/mkcacerts
Note
Faire un très grand copier/coller directement dans un terminal
peut donner un fichier corrompu. Copier depuis un éditeur peut
contourner ce problème.
Générez le fichier cacerts de
OpenJDK en tant qu'utilisateur
root :
if [ -f /opt/jdk/jre/lib/security/cacerts ]; then
mv /opt/jdk/jre/lib/security/cacerts \
/opt/jdk/jre/lib/security/cacerts.bak
fi &&
/opt/jdk/bin/mkcacerts \
-d "/etc/ssl/certs/" \
-k "/opt/jdk/bin/keytool" \
-s "/usr/bin/openssl" \
-o "/opt/jdk/jre/lib/security/cacerts"
Utilisez les commandes suivantes pour vérifier si le fichier
cacerts a été installé avec
succès :
cd /opt/jdk
bin/keytool -list -keystore jre/lib/security/cacerts
A l'invite "Enter keystore password:", appuyez sur "Entrée" s'il
n'y a pas de mots de passe défini. Si le fichier cacerts est installé correctement, vous verrez
une liste de certificats avec des informations relatives à
chacun. Sinon, vous devez les réinstaller.