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 forunir un
environnement d'exécution complet pour lancer des programmes
Java.
Ce paquet est connu pour se construire correctement sur une
plateforme LFS-7.8.
![[Note]](../images/note.png)
Note
Un greffon de navigateur et une implémentation de webstart, aussi
bien que le moteur de sons pulseaudio sont fournis par le projet
Icedtea. Pour fournir une implémentation complète, vous devrez
installer plus tard IcedTea-Web-1.6.1 et IcedTea-Sound-1.0.1.
OpenJDK est du code 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 tierces à utiliser des classes
fournit par des programmes libres sans l'obligation que le
programme tierce soit également libre. Comme avec la LGPL, toutes
les modifications faite dans des parties d'un programme libre d'une
application tierce,doit également être librement disponible.
Note
Les sources de OpenJDK inclu une
très complète, open source suite de tests appelée JTreg. Les instructions de tests suivantes
permettent de tester le JDK juste construit pour une
compatibilité raisonnable avec le JDK fermé d'Oracle. Cependant,
pour qu'une implémentation indépendante revendique la
compatibilité, incluant le projet sponsorisé par Oracle JDK, elle
doit passer une suite de tests fermée JCK/TCK. Pas de revendication de
compatibilité, même une compatibilité partielle, peut être faite
sans passer une suite de tests approuvées.
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 fournit sur la
page java-1.8.0.60 comme le JVM construit avec les
instructions suivantes ont été testée avec
TCK. Toutes les versions qui seront construites en utilisant
les instructions données, ne pourront pas revendiquer d'être
compatible avec le JDK propriétaire, sans que l'utilisateur
demande, et réussissent 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/jdk8u60/archive/jdk8u60-b27.tar.bz2
Somme de contrôle MD5 du téléchargement :
bcaf6f51627e8f052eff0fdcd8578b4f
Taille de téléchargement: 395 Ko
-
En supplément du paquet principal, les instructions suivantes
commenent par télécharger sept archives de sous-projet, pour
une taille totale de 52 Mo.
-
Estimation de l'espace disque requis : 3.7 Go
(additional 371 Mo for tests)
-
Estimation du temps de construction : 12 SBU (additional
100 SBU for tests)
Téléchargements supplémentaires
Dépendances de OpenJDK
Dépendances requises
Un binaire existant ( java-1.8.0.60 ou une version construite récente
de ce paquet, ALSA-Library-1.0.29, cpio-2.11, Cups-2.1.0,
UnZip-6.0,
which-2.21, Xorg Libraries et
Zip-3.0.
Recommandées
Certificate Authority
Certificates, giflib-5.1.1 et Wget-1.16.3
Facultatives
mercurial-3.5.1 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 jdk8u60-b27.tar.bz2, allez dans le répertoire
extrait, ensuite continuez avec les instruction suivantes :
cat > subprojects.md5 << EOF &&
002432f496bab8c85f6baf61d65dca27 corba.tar.bz2
a4ebec7c61aa154804761127a1f75eae hotspot.tar.bz2
9a7b2a534b4a01ebb559b60023882809 jaxp.tar.bz2
7ff3e1154d79d208ae89c24355254b49 jaxws.tar.bz2
57ccac8dc86d993e64ff920feb9e54ab langtools.tar.bz2
2f5874a62c2bc74b99118f66d82886da jdk.tar.bz2
a8fccf7be7451205e6048b9b2fcd5b24 nashorn.tar.bz2
EOF
for subproject in corba hotspot jaxp jaxws langtools jdk nashorn; do
wget -c http://hg.openjdk.java.net/jdk8u/jdk8u60/${subproject}/archive/jdk8u60-b27.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 recommandée, décompressez
la également:
tar -xf ../jtreg-4.1-b12-389.tar.gz
Note
Avant de continuer, vous devez vous assurer que votre variable
d'environnement PATH contient
l'endroit 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éveloppeur 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=60 \
--with-build-number=b27 \
--with-milestone=BLFS \
--enable-unlimited-crypto \
--with-zlib=system \
--with-giflib=system &&
make DEBUG_BINARIES=true 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, pas seulement ces tests échoueront, mais le
nettoyage des tests laissera des JVM orphelines lancées. Il y en
aura beaucoup. Rédémarrer peut être la solution la plus simple.
Tester la nouvelle version construite de JVM implique quelques
étapes. En premier, il est mieux de lancer la suite de test dans un
frame buffer 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écéssaire 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é comme suivant:
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é 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 condition,
comme si l'ordinateur est connecté sur un résau. Ausi, certain test
peuvent dépasser le temps si la machine est sous chargé.
Ensuite quelques nettoyages doivent être fait. Les instructions
suivantes arrêtent seulement le frame buffer, mais il a été signalé
que quelque 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.60 &&
chown -R root:root /opt/OpenJDK-1.8.0.60
Il y a maintenant deux SDK d'OpenJDK installé 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, faite la ligne suivante en tant
qu'utilisateur root :
ln -v -nsf OpenJDK-1.8.0.60 /opt/jdk
Si vous le souhaitez, vous pouvez installer un fichier .desktop
correspondant à une netrée dans le menu du bureau pour policytool. En premier, vous
devez obtenir un icone de IcedTea-Web-1.6.1:
tar -xf ../icedtea-web-1.6.1.tar.gz \
icedtea-web-1.6.1/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]= » données par votre traduction.
Explications des commandes
sh configure...: Le
niveau supérieur de configure est une
enveloppe pour autotools. Ce n'est pas un éxé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écéssaire si java est trouvé dans le
PATH.
--with-update-version:
Actuellement, le système de construction n'inclu pas le numéro de
mise à jour dans la chaine de version. Il est spécifié ici.
--with-build-number: De
nouveau, le sysètme de construction n'inclu 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:
A cause des limitations de l'usage de la cryptographie dans certain
pays, il y a le possibilité de limiter la taille des clés de codage
et l'utilisation de certains algorythmes dans un fichier de
filtrage. Ce paramètre permet de garder un fichier de filtrage sans
restriction. Il est de la responsabilité de l'utilisateur de
s'assurer de son propre 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-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
nomvre de processeurs . Notez que si vous spécifiez N=1, certaines
parallélisations peuvent être utilisées pendant la construction.
Les SBU donnés sont avec les travaux parallèles désactivés, sur un
simple processeur, simple coeur, sur une machine virtuelle.
--with-cacerts-file=...: Spécifie ou
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
all: La constuction échoue sur les machines 32 bits
si DEBUG_BINARIES n'est pas initialisé à true.
find ... -iname '*.diz'
-delete: Cette comande suppriment les fichier
redondants.
Configuration de
OpenJDK
Information de configuration
Normallement, l'environnement JAVA a été configurée après
l'installation de la version binaire, et peut être utilisé avec
le paquet fraichement construit aussi bien. Regardez Configuring the JAVA
environment dans le cas ou vous voudriez modifier quelque
chose.
Pour tester que les pages de man sont correctement installées,
tapez source
/etc/profile et man
java pour afficher les pages de man respectives.
Installez ou mettez à
jour les fichiers "JRE Certificate Authority Certificates"
(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 Certificate Authority
Certificates, en utilisant la procedure 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 "Enter" s'il
n'y a pas de mots de passe de 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.