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.7.
![[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.5.2 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.31 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
Les fichiers suivants peuvent être téléchargé depuis le dépot
mercurial d'OpenJDK en utilisant l'adresse
http://hg.openjdk.java.net/jdk8u/jdk8u/<component>/archive/jdk8u31-b13.tar.bz2,
ou <component> est le nom du composant JVM (corba, hotspot,
et ainsi de suite) mais cela implique de renommer les fichiers
téléchargés, et renommer les répertoires extraits. Par confort les
auteurs de BLFS ont rendu les fichiers disponibles sur le site web
LFS.
Téléchargements supplémentaires
Dépendances de OpenJDK
Dépendances requises
Un binaire existant ( java-1.8.0.31 ou une version construite récente
de ce paquet, ALSA-Library-1.0.28, cpio-2.11, Cups-2.0.2,
UnZip-6.0,
which-2.20, Xorg Libraries et
Zip-3.0.
Recommandées
Certificate Authority
Certificates et giflib-5.1.1
Facultatives
mercurial-3.3 et twm-1.0.8 (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 jdk8u31-b13.tar.bz2, allez dans le répertoire
extrait, ensuite continuez avec les instruction suivantes :
tar -xf ../corba.tar.xz &&
tar -xf ../hotspot.tar.xz &&
tar -xf ../jaxp.tar.xz &&
tar -xf ../jaxws.tar.xz &&
tar -xf ../jdk.tar.xz &&
tar -xf ../langtools.tar.xz &&
tar -xf ../nashorn.tar.xz
Si vous avez téléchargé la suite de tests, décompressez la
également:
tar -xf ../jtreg4.1-b10.tar.gz
Corrigez un problème avec la nouvelle API de giflib (depuis 5.1.0):
sed -e 's/DGifCloseFile(gif/&, NULL/' \
-e '/DGifOpen/s/c)/c, NULL)/' \
-i jdk/src/share/native/sun/awt/splashscreen/splashscreen_gif.c
corrigez un bogue dans un script shell utilisé pour initialisé les
drapeaux pour make:
sed 's/\([ \t]\)\]\([^\]\)/\1I]\2/g' \
-i hotspot/make/linux/makefiles/adjust-mflags.sh
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=31 \
--with-build-number=b13 \
--with-milestone=BLFS \
--enable-unlimited-crypto \
--with-zlib=system \
--with-giflib=system &&
make DEBUG_BINARIES=true all
Il semble que l'infrastructure de tests de OpenJDK est en cours de
réalisation, donc tester la nouvelle version construite de JVM
demande quelques étapes. En premiet, 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/' \
-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 la suite:
LANG=C make -k -C test \
JT_HOME=${JT_HOME} \
JT_JAVA=${JT_JAVA} \
PRODUCT_HOME=${PRODUCT_HOME} all
LANG=C ${JT_HOME}/linux/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.
Finallement, arrêtez le frame buffer virtuel et nettoyez:
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 :
find build/*/images/j2sdk-image -iname \*.jar -exec chmod a+r {} \; &&
chmod a+r build/*/images/j2sdk-image/lib/ct.sym &&
find build/*/images/j2sdk-image -iname \*.diz -delete &&
find build/*/images/j2sdk-image -iname \*.debuginfo -delete &&
cp -R build/*/images/j2sdk-image /opt/OpenJDK-1.8.0.31 &&
chown -R root:root /opt/OpenJDK-1.8.0.31
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.31 /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.5.2:
tar -xf ../icedtea-web-1.5.2.tar.gz \
icedtea-web-1.5.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]= » 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. 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 si DEBUG_BINARIES n'est
pas initialisé à true.
find ... -iname '*.jar' -exec chmod
a+r {} ; et les lignes suivantes: Corrige les
permissions dans quelques fichiers de bibliothèque, pour permettre
que tous les utilisateurs puissent y accéder.
find ... -iname '*.diz'
-delete: Cette comande et la suivante 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)
Utilisez la procédure suivante pour installer le fichier
cacerts ou pour en générer un
nouveau si Certificate Authority
Certificates a été mis à jour. Pour commencer, s'il n'est pas
déjà présent, générez 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.
Si vous avez besoin de générer un fichier cacerts, et qu'il y en a déjà un dans
/opt/jdk/jre/lib/security, il est
mieux de faire une sauvegarde. Ensuite vous pouvez en créer un
nouveau, en tant qu'utilisateur root :
/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.