# ZOS: Lanceur JVM personnalisé JZOS

{{INLINETOC}}

## Installation de JZOS 

1) Télécharger le fichier .zip de distribution à l'adresse http://www.alphaworks.ibm.com/tech/zosjavabatchtk/download. 

<WRAP info>télécharger le fichier jzos124.zip à partir du répertoire /u/prak021/jbatch/setup de l'hôte via FTP.</WRAP> 

2) Extraire le contenu .zip dans un répertoire local (par exemple, c: \ jzos). 

3) Transférer les fichiers extraits vers le système z/OS. Les fichiers suivants doivent être téléchargés en binaire : 
  * jzos.pax 'YOURUSERID.jzos.pax' 
  * jzos.loadlib.xmit 'YOURUSERID.jzos.loadlib.xmit' 
  * jzos.sampjcl.xmit 'YOURUSERID.jzos.sampjcl.xmit' 

4) Si on effectue un téléchargement via FTP, utiliser les commandes suivantes: 

```
ftp> bin 
ftp> quote site recfm=fb 
ftp> quote site lrecl=80 
ftp> put jzos.sampjcl.xmit ‘YOURUSERID.JZOS.SAMPJCL.XMIT' 
ftp> quote site cyl 
ftp> quote site pri=2 
ftp> put jzos.loadlib.xmit 'YOURUSERID.JZOS.LOADLIB.XMIT' 
ftp> put jzos.pax 'YOURUSERID.JZOS.PAX' 
ftp> quit  
```

5) Se connecter à TSO.

6) Entrer la commande TSO suivante pour décharger la bibliothèque de modules de chargement dans un fichier PDSE: 

```
tso receive inda('YOURUSERID.JZOS.LOADLIB.XMIT') 
```

7) Au message "Entrez les paramètres de restauration ...", entrer: 

```
da('YOURUSERID.JZOS.LOADLIB')  
```

<WRAP info>Si on un message d'erreur "Impossible d'envoyer un message avec une invite de réponse",est retournée activer l'option en tapant la commande: \\ \\ `tso profile prompt`</WRAP>

<WRAP tip>Si le fichier XMIT est déchargé dans `YOURUSERID.PRIVATE.JZOS124.LOADLIB`, supprimer le et essayer de nouveau le transfert avec:\\ \\ `tso receive inda('YOURUSERID.JZOS.LOADLIB.XMIT')`\\ \\Au message  "Entrez les paramètres de restauration ...", entrer:\\ \\ `da(JZOS.LOADLIB)`</WRAP>

8) Répéter l'opération pour décharger l'exemple de PDS JCL: 

```
tso receive inda('YOURUSERID.JZOS.SAMPJCL.XMIT')
```
Au message "Entrez les paramètres de restauration ...", entrer: 

```
da('YOURUSERID.JZOS.SAMPJCL')
```

9) À partir du shell z/OS Unix, accéder au répertoire où on veut créer les fichiers JZOS HFS (/u/YOURUSERID) et décharger le jeu de données pax: (Ceci créera un répertoire nommé "jzos" par rapport au répertoire actuel, qui sera appelé plus tard **JZOS\_HOME**)

```
pax -rvf “//'YOURUSERID.JZOS.PAX'”
```

10) Si pax a réussi, supprimer les fichiers suivants: 
  * YOURUSERID.JZOS.SAMPJCL.XMIT
  * YOURUSERID.JZOS.LOADLIB.XMI

## Installation de Tomcat

Le conteneur de servlets Apache Tomcat peut être installé rapidement et facilement à l'aide de la boîte à outils JZOS. 

1) Créer un nouveau répertoire /u/prak021/jbatch/users/YOURUSERID

```
mkdir /u/prak021/jbatch/users/YOURUSERID
```

2) Télécharger la version .zip de la distribution binaire de Tomcat et la charger (en mode binaire) vers/u/prak021/jbatch/users. 

Apache Jakarta page de téléchargement: http://jakarta.apache.org/site/binindex.cgi
binary Distribution .zip: http://tomcat.apache.org/download-55.cgi 

<WRAP info>On peut également trouver les fichiers d'installation au format binaire zip dans le répertoire/u/prak021/jbatch/setup et les copier directement dans le répertoire personnel /u/YOURUSERID!\\ \\ `cp /u/prak021/jbatch/setup/apache-tomcat-5.5.15.zip /u/prak021/jbatch/users/YOURUSERID`</WRAP>

3) Depuis le shell z/OS Unix, accéder au répertoire personnel et y extraire le fichier zip Tomcat.

<WRAP info>cela créera un répertoire "apache-tomcat-5.5.15" sous le répertoire actuel!</WRAP>

```
cd /u/prak021/jbatch/users/YOURUSERID
jar -xvf apache-tomcat-5.5.15.zip
```

4) Supprimer le fichier zip:

```
rm apache-tomcat-5.5.15.zip
```

5) Pour plus de commodité, créer un lien symbolique vers la distribution Tomcat:

```
ln -s apache-tomcat-5.5.15 tomcat 
```

6) Modifier les ports dans server.xml:
  * Télécharger `/u/prak021/jbatch/users/YOURUSERID/apache-tomcat-5.5.15/conf/server.xml` via FTP en mode binaire 
  * Éditer `server.xml` et modifier tous les ports, par exemple changez 8080 en 80xx 
  * Télécharger le fichier server.xml modifié dans `/u/prak021/jbatch/users/YOURUSERID//apache-tomcat-5.5.15/conf/server.xml` via FTP en mode binaire. 

7) Créer un nouveau membre TOMCAT dans `YOURUSERID.SAMPLES.JCL` et y insérer le contenu JCL suivant: 

```
//TOMCAT JOB
//PROCLIB JCLLIB ORDER=YOURUSERID.JZOS.SAMPJCL
//...
//JAVA EXEC PROC=EXJZOSVM,VERSION='50', 
// JAVACLS='org.apache.catalina.startup.Bootstrap',
// ARGS='start' 
//STDENV DD * 
# Ceci est un script shell qui 
# configure toutes les variables d'environnement pour la machine virtuelle Java. 
# Les variables doivent être exportées pour être vues par le lanceur. 
. /etc/profile
export JZOS_HOME=/u/YOURUSERID/jzos 
export TOMCAT_HOME=/u/prak021/jbatch/users/YOURUSERID/apache-tomcat-5.5.15 
export JAVA_HOME=/u/prak021/jbatch/local/java/J5.0 
export PATH=/bin:"${JAVA_HOME}"/bin: 
LIBPATH=/lib:/usr/lib:"${JAVA_HOME}"/bin:"$JAVA_HOME"/bin/classic 
LIBPATH="$LIBPATH":"${JZOS_HOME}" export 
LIBPATH="$LIBPATH": 
CLASSPATH="${JAVA_HOME}/lib/tools.jar" 
CLASSPATH="$CLASSPATH":"${TOMCAT_HOME}/bin/bootstrap.jar" 
CLASSPATH="$CLASSPATH":"${JZOS_HOME}/jzos.jar" 
CLASSPATH="$CLASSPATH":"${TOMCAT_HOME}/bin/commons-logging-api.jar" export CLASSPATH="$CLASSPATH":
# Configuration des options spécifiques à JZOS 
# Utiliser cette variable pour spécifier le codage pour DD STDOUT et STDERR 
#export JZOS_OUTPUT_ENCODING=Cp1047 
# Utiliser cette variable pour empêcher JZOS de traiter les commandes de l'opérateur MVS 
#export JZOS_ENABLE_MVS_COMMANDS=false 
# Utiliser cette variable pour fournir des arguments supplémentaires à la commande principale 
#export JZOS_MAIN_ARGS="" 
# Configuration des Options JVM 
# Tomcat nécessite le fichier ASCII par défaut.
IJO="-Xms64m -Xmx128m" 
IJO="$IJO -Dfile.encoding=ISO8859-1" 
IJO="$IJO -Djzos.home=${JZOS_HOME}" 
IJO="$IJO -Dcatalina.base=${TOMCAT_HOME}" 
IJO="$IJO -Dcatalina.home=${TOMCAT_HOME}" 
IJO="$IJO -Djava.io.tmpdir=${TOMCAT_HOME}/temp" 
IJO="$IJO -Djava.endorsed.dirs=${TOMCAT_HOME}/common/endorsed"
# Décommenter ce qui suit si vous souhaitez exécuter sans JIT 
#IJO="$IJO -Djava.compiler=NONE" 
export IBM_JAVA_OPTIONS="$IJO " 
export JAVA_DUMP_HEAP=false 
export JAVA_PROPAGATE=NO 
export IBM_JAVA_ZOS_TDUMP=NO 
//
```

8) Soumettre le JCL 

9) Vérifier les résultats avec SDSF: STDOUT DD devrait contenir quelque chose comme ceci (mais variera en fonction de la version de JDK):

```
[INFO] Http11Protocol - Initializing Coyote HTTP/1.1 on http-8080 
[INFO] Catalina - Initialization processed in 129605 ms 
[INFO] StandardService - Starting service Catalina 
[INFO] StandardEngine - Starting Servlet Engine: Apache Tomcat/ 
[INFO] StandardHost - XML validation disabled [INFO] StandardHost - Create Host deployer for direct deployment ( non-jmx ) [INFO] StandardHostDeployer - Processing Context configuration file URL ... 
[INFO] Catalina - Server startup in 454422 ms 
```

10) Tester Tomcat: Aller à `http://<adresse-ip>:80xx/`

Cela devrait afficher la page d'administration de Tomcat: 

11) Purger le travail TOMCAT 


### Installer des applications JZOS 

1) Pour déployer des applications, on doit tout d'abord installer la page d’administration Tomcat: 

décompresser le fichier /u/prak021/jbatch/setup/apache-tomcat-5.5.15-admin.zip sur la page d’accueil Tomcat: 

```
cd/u/prak021/jbatch/users/YOURUSERID 
jar –xvf/u/prak021/jbatch/setup/apache-tomcat-5.5.15-admin.zip
```

2) Télécharger `/u/prak021/jbatch/users/YOURUSERID/apache-tomcat-5.5.15/conf/tomcat-users.xml` en binaire mode via FTP. 

3) Ajouter les lignes suivantes dans le fichier xml: 

```
<role rolename="admin"/> 
<role rolename="manager"/> 
... 
<user username="admin" password="manager" roles="admin,manager"/>
```

4) Enregistrer le fichier `tomcat-users.xml` et le transférer à nouveau sur l'hôte en mode binaire vers `/u/prak021/jbatch/users/YOURUSERID/apache-tomcat-5.5.15/conf`

5) Redémarrer Tomcat en soumettant le JCL TOMCAT à nouveau. 

6) Installer et tester des exemples de servlet JZOS: 

  * Télécharger le fichier `jzos.war` de `/u/prak021/jbatch/setup`
  * Le déployer avec le gestionnaire Tomcat sur la page admin (s'identifier avec le nom d'utilisateur «admin» et le mot de passe «manager». ).

7) Une fois le fichier .war déployé, accéder au site Web suivant: `http://<adresse_ip:80xx/jzos` et tester les exemples de servlet. 

8) Purger le travail TOMCAT

## Autres programmes Java MVS 

Ce chapitre traite de différents programmes Java qui accèdent aux ressources MVS natives. 
Les fichiers source Java de ce chapitre sont disponibles ici:/u/prak021/jbatch/source. 

### Ecrire dans la console opérateur avec Java 

Ce chapitre explique comment écrire des messages dans la console opérateur depuis Java 

1) Copier /u/prak021/jbatch/source/Wto.java dans /u/YOURUSERID/Wto.java: 

```
cp /u/prak021/jbatch/source/Wto.java /u/YOURUSERID/myjava/Wto.java
```

2) Examiner le code source:

```
cd /u/YOURUSERID/myjava
oedit ConditionCode.java 
```

3) Fermer le fichier avec F3. 

4) Compiler ce fichier avec `javac`: 

```
javac Wto.java -classpath /u/YOURUSERID/jzos/jzos.jar
```

5) Quitter le shell OMVS en entrant 

```
Exit 
```

6) Copier le JCL YOURUSERID.JZOS.SAMPJCL(EXJZOSVM)' dans un nouveau JCL 'YOURUSERID.SAMPLES.JCL(WTO)'

7) Modifier le JCL, en le mettant à jour pour qu'il pointe vers la bibliothèque de modules de chargement JZOS que intallée en fonction de la machine virtuelle Java disponible: 

```
//XXXXXXX JOB                            <- Renseigner le JOB-Name 
//PROCLIB JCLLIB ORDER=YOURUSERID.JZOS.SAMPJCL 
... 
//JAVA EXEC PROC=EXJZOSVM,VERSION='13',  <- indiquer la VERSION='14' ou VERSION='50' 
// JAVACLS='Wto'                         <- indiquer JAVACLS                  
//STDENV DD *   
... 
export JZOS_HOME=/u/YOURUSERID/jzos 
export JAVA_HOME=/usr/lpp/java/IBM/J1.3   <- Indiquer la directory de la JVM                       
...
# Customize your CLASSPATH here   
CLASSPATH=/u/YOURUSERID/myjava       
... 
```

8) Soumettre le JCL et vérifier le résultat avec SDSF.

9) Accéder à la console de l'opérateur et rechercher l'OMC.

### Gestion des codes de condition avec Java 

Ce chapitre explique comment créer un petit réseau de travaux basé sur les codes de retour Java.

10) Copier le fichier /u/prak021/jbatch/source/ConditionCode.java dans/u/YOURUSERID/ConditionCode.java: 

```
cp /u/prak021/jbatch/source/ConditionCode.java /u/YOURUSERID/myjava/ConditionCode.java
```

11) Examiner le code source: 

```
cd /u/YOURUSERID/myjava 
oedit ConditionCode.java 
```

12) Fermer le fichier avec F3. 

13) Compiler ce fichier avec `javac`:

```
javac ConditionCode.java
```

14) Quitter le shell OMVS en entrant 

```
Exit
```

15) Copier `/u/prak021/jbatch/source/Wto.java` dans `YOURUSERID.SAMPLES.JCL(CC)`

16) Modifier JAVACLS, ARGS et Classpath dans le JCL:

```
//XXXXXXX JOB                            <- Renseigner le JOB-Name 
//PROCLIB JCLLIB ORDER=YOURUSERID.JZOS.SAMPJCL 
... 
//JAVA EXEC PROC=EXJZOSVM,VERSION='13',  <- indiquer la VERSION='14' ou VERSION='50' 
// JAVACLS='ConditionCode'               <- indiquer JAVACLS
// ARGS=’1’                   
//STDENV DD *   
... 
export JZOS_HOME=/u/YOURUSERID/jzos 
export JAVA_HOME=/usr/lpp/java/IBM/J1.3   <- Indiquer la directory de la JVM                       
...
# Customize your CLASSPATH here   
CLASSPATH=/u/YOURUSERID/myjava       
... 
```

17) Dans le JCL, ajoutez le script suivant qui démarre un HelloWorld si le code de retour du programme Java ConditionCode est '1' 

```
//************************************************  
// IF (RC = 1) THEN  
//************************************************ 
//HELLO EXEC PROC=EXJZOSVM,VERSION='13',  
// JAVACLS='com.dovetail.jzos.sample.HelloWorld'  
//STDENV DD *  
# Il s'agit d'un script shell qui 
# configure toutes les variables d'environnement pour la machine virtuelle Java. 
# Les variables doivent être exportées pour être vues par le lanceur. ./etc/profile 
export JZOS_HOME=/u/YOURUSERID/jzos
export APPL_HOME=/u/YOURUSERID/myjava
export JAVA_HOME=/usr/lpp/java/IBM/J1.3
export PATH="$PATH":"${JAVA_HOME}"/bin: 
LIBPATH="$LIBPATH":"${JAVA_HOME}"/bin 
LIBPATH="$LIBPATH":"${JAVA_HOME}"/bin/classic 
LIBPATH="$LIBPATH":"${JZOS_HOME}" 
export LIBPATH="$LIBPATH": 
# Personnaliser votre CLASSPATH ici 
# Ajoute les conteneurs requis JZOS à la fin de CLASSPATH 
for i in "${JZOS_HOME}"/*.jar; do
CLASSPATH="$CLASSPATH":"$i"  
done  
export CLASSPATH="$CLASSPATH":
# Configuration des options spécifiques de JZOS 
# Utiliser cette variable pour spécifier codage pour DD STDOUT et STDERR 
#export JZOS_OUTPUT_ENCODING=Cp1047 
# Utilisez cette variable pour empêcher JZOS de traiter les commandes de l'opérateur MVS 
#export JZOS_ENABLE_MVS_COMMANDS=false 
# Utiliser cette variable pour fournir des arguments supplémentaires à la propriété 
#export JZOS_MAIN_ARGS="" 
# Configuration des options JVM 
IJO="-Xms16m -Xmx128m" 
IJO="$IJO -Djzos.home=${JZOS_HOME}"
# Décommenter ce qui suit si vous souhaitez exécuter sans JIT
#IJO="$IJO -Djava.compiler=NONE"
# Décommenter ce qui suit si vous voulez exécuter avec l'encodage de fichier Ascii .. 
IJO="$IJO -Dfile.encoding=ISO8859-1" 
export IBM_JAVA_OPTIONS="$IJO " 
export JAVA_DUMP_HEAP=false 
export JAVA_PROPAGATE=NO 
//************************************************  
// ENDIF 
//************************************************  
// 
```

18) Soumettre le JCL et vérifier la sortie avec SDSF.

19) Modifier ARGS = ’0’ dans le JCL. 

20) Soumettre à nouveau le JCL et vérifiez la sortie avec SDSF. HelloWorld ne doit pas être invoqué